diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2dc1b8fd..ddea6de0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -73,8 +73,8 @@ asset normalization:
 $ pnpm test:inner
 ```
 
-Run workspace unit suites, lint, and generated mention/navigation freshness
-checks in the medium loop:
+Run workspace unit suites, lint, API links, and generated mention/navigation
+freshness checks in the medium loop:
 
 ```console
 $ pnpm test:medium
diff --git a/WRITING.md b/WRITING.md
index e996e0e6..576a1ebb 100644
--- a/WRITING.md
+++ b/WRITING.md
@@ -79,9 +79,12 @@ than translating another port's spelling by analogy.
 
 Prefer a tested source example to a manually copied snippet. This site's
 [`remark-port-code.mjs`](site/src/plugins/remark-port-code.mjs) reads fences
-with `file="..."` from its configured port checkout or docs worktree;
+with `file="..."` from the revision-bound example cache;
 `region="..."` selects text between the source's region markers. Read that
-plugin's mapping before editing an example source. Port mutations follow
+plugin's mapping before editing an example source. Regenerate the cache with
+`node scripts/gen-example-sources.mjs`: it reads committed files at the source
+revision recorded by the API model or wrapper guide artifact. Working-tree
+edits and a newer HEAD do not change the documented example. Port mutations follow
 [Repository boundaries](AGENTS.md#repository-boundaries).
 
 Preserve source metadata, region markers, doctest prompts, and expected
@@ -92,21 +95,76 @@ paths and a coverage floor, but it does not execute every language example.
 It scans `.md` pages, not MDX, and cannot check source existence when the
 relevant checkout is absent.
 
-For inline examples, record the verification performed in the change's
-review notes. Do not claim a code fence is executed merely because it has a
-language tag. Preserve collected examples when changing their formatting.
+Every executable example must work when copied with its displayed setup.
+Include imports, an entry point, required inputs, and cleanup. Show dependency
+and run commands. Do not rely on variables or helper code from another example.
+A source file that only declares functions is not a runnable program.
+
+Run the exact displayed program against the documented library revision.
+Record its commands, source revision, result, and content hash in the review.
+Tests that add a hidden prelude or execute a larger source file do not verify
+the copied example. Preserve collected examples when changing formatting.
+
+Put explanatory comments on separate lines above the code they describe.
+Wrap example comments at 80 columns, including indentation. Put long source
+links and attribution in prose outside the code block.
 
 ### Examples across ports
 
+Port pages teach only their selected language. Root pages explain tmux behavior
+and may compare languages or show equivalent examples in tabs.
+
+Keep a language's prose, headings, caveats and examples in an ownership region:
+
+```markdown
+<!-- port:go -->
+Pass a context to each operation and check the returned error.
+<!-- /port -->
+```
+
+Comma-separated port slugs select several languages. Regions can nest;
+`port:root` marks framing that appears only on the shared page. Root builds
+keep every region. The same selection applies to HTML, headings, search,
+Markdown copies and LLM exports. A page's `supportedPorts` array restricts
+shared prose to ports with verified coverage; native source guides supply
+the other ports' documentation and task equivalents.
+
 Keep equivalent examples together under one task heading, using the actual
-language fence tags. The site groups alternative ports into tabs; a build
-for one port filters out the others. Language-specific lead-ins should stay
-with their example. Separate sequential examples and distinct tasks with
-their own explanation rather than forcing them into an alternatives group.
+language fence tags. Separate sequential examples and distinct tasks with
+their own explanation. Check the selected page for empty sections and links
+that accidentally leave its port or version.
 
 `console`, JSON, and other shared fences survive port filtering. Check that
 shared setup still makes sense in every port's rendered page.
 
+Run the Go examples against isolated servers when changing their calls:
+
+```console
+$ python3 scripts/check-go-prose.py --checkout /path/to/libtmux-go
+```
+
+This checks eight examples covering transport, input, capture, options, hooks,
+waiting, and cleanup at the integrated Go revision. It requires Go and tmux
+on `PATH`; it is separate from the ordinary docs test loop.
+
+For workspace command examples, build the native CLI from the source revision
+linked by the page, then run:
+
+```console
+$ python3 scripts/check-workspace-prose.py \
+    --port go \
+    --binary /path/to/tmux-workspace
+```
+
+The runner executes the command, automation, export and troubleshooting examples,
+then loads the configuration and gallery documents. It checks pane counts,
+options, focus, directories, launch environment, overwrite refusal, editor errors,
+invalid patterns and unsupported fields on a private tmux socket.
+Node, tmux and the selected CLI's runtime must be on `PATH`. Set
+`TMUX_WORKSPACE_PYTHON` to a compatible interpreter to include optional shell
+inspection; its absence is reported as a skip. Use `--report` to save command
+results and content hashes, and record the native build revision with that report.
+
 ## Content collections and MDX
 
 [`site/src/content.config.ts`](site/src/content.config.ts) owns collection
diff --git a/package.json b/package.json
index 6a9f41a8..3f4aa00e 100644
--- a/package.json
+++ b/package.json
@@ -22,7 +22,10 @@
   "packageManager": "pnpm@12.6.0",
   "devDependencies": {
     "@biomejs/biome": "catalog:",
-    "typescript": "catalog:",
-    "oxlint": "catalog:"
+    "happy-dom": "catalog:",
+    "mdast-util-from-markdown": "2.0.3",
+    "mdast-util-to-markdown": "2.1.2",
+    "oxlint": "catalog:",
+    "typescript": "catalog:"
   }
 }
diff --git a/packages/api-model/src/mentions.ts b/packages/api-model/src/mentions.ts
index 5ba892de..c8393b90 100644
--- a/packages/api-model/src/mentions.ts
+++ b/packages/api-model/src/mentions.ts
@@ -101,11 +101,12 @@ const FENCE_PORT: Record<string, string> = {
 }
 
 /** Inline references in prose, including port sections, tables, and existing links. */
-export function proseMentions(markdown: string, portByLabel: Record<string, string>): ProseMention[] {
+export function proseMentions(markdown: string, portByLabel: Record<string, string>, portAt?: (offset: number) => string | undefined): ProseMention[] {
   const out: ProseMention[] = []
   const lines = markdown.split('\n')
   const context: { port?: string; before: string }[] = []
-  const bodyLines = lines.map(() => '')
+  // Keep offsets stable when frontmatter, headings and examples are masked.
+  const bodyLines = lines.map((line) => ' '.repeat(line.length))
   const sections: { depth: number; port?: string }[] = []
   let fence: string | undefined
   let fencePort: string | undefined
@@ -157,7 +158,7 @@ export function proseMentions(markdown: string, portByLabel: Record<string, stri
     if (!ctx) continue
     const before = ctx.before + beforeMatch.slice(beforeMatch.lastIndexOf('\n') + 1)
     const linked = body[match.index - 1] === '[' && body.slice(match.index + match[0].length).startsWith('](')
-    out.push({ text, port: ctx.port, before, line, ...(linked ? { linked: true } : {}) })
+    out.push({ text, port: portAt?.(match.index) ?? ctx.port, before, line, ...(linked ? { linked: true } : {}) })
   }
   return out
 }
diff --git a/packages/api-model/src/prose.ts b/packages/api-model/src/prose.ts
index 1d7ab385..359dbd85 100644
--- a/packages/api-model/src/prose.ts
+++ b/packages/api-model/src/prose.ts
@@ -1,5 +1,6 @@
 import type { ApiModel, ApiProduct, ApiSymbol } from './model.ts'
 import type { Resolver } from './resolver.ts'
+import { builtinHref } from './builtins.ts'
 
 /**
  * Whether a code span in prose is a reference to the API, and to what.
@@ -162,6 +163,7 @@ const NOT_API: { why: string; test: RegExp }[] = [
   // Environment variables and tmux option names are SCREAMING_CASE and
   // belong to tmux or the shell, not to a port.
   { why: 'environment variable', test: /^[A-Z][A-Z0-9_]{2,}$/ },
+  { why: 'single-letter flag or type parameter', test: /^[A-Z]$/ },
   // An expression, not a name: it carries arguments, a string, or a glob.
   { why: 'expression, not a symbol', test: /["']|\*|=>|\.\.\./ },
   { why: 'expression, not a symbol', test: /^\(|,\s/ },
@@ -175,7 +177,7 @@ const NOT_API: { why: string; test: RegExp }[] = [
   { why: 'method without a receiver', test: /^[.:]/ },
   // Test and example fixtures live in files the extractors exclude, so they
   // are real classes that are deliberately not public API.
-  { why: 'test or example fixture', test: /(Tests?|TestCase|RunTest)$|^Test[A-Z]/ },
+  { why: 'test or example fixture', test: /(Tests?|TestCase|RunTest)$|^Test[A-Z]|^Example(?:\(\))?$/ },
 ]
 
 /** Why this span is not an API reference, or undefined if it might be. */
@@ -248,16 +250,21 @@ export function decideMention(
 
   const named = ctx.before ? portFromSentence(ctx.before) : undefined
   const tried: string[] = []
+  let ambiguous = false
   for (const port of [named, ctx.pagePort]) {
     if (!port || !models[port]) continue
     const res = resolver.resolve(port, text, ctx.product)
+    ambiguous ||= res.how === 'ambiguous'
     tried.push(`${port}:${res.how}`)
     const hit = link(port, res)
     if (hit) return hit
+    const builtin = builtinHref(port, text)
+    if (builtin) return { kind: 'link', port, href: builtin, title: `${text}: ${PORT_NAME[port]}`, external: true }
   }
-  // Product pages have an authored port. Shared comparisons retain their
-  // cross-port fallback when a preceding fence only suggests a language.
-  if (ctx.product && tried.length) return { kind: 'unresolved', why: 'not defined in the stated port', tried }
+  // A known language must never resolve a similarly named API in another port.
+  if (tried.length) return ambiguous
+    ? { kind: 'skip', why: 'ambiguous within the stated port; qualify the receiver to link it' }
+    : { kind: 'unresolved', why: 'not defined in the stated port', tried }
 
   // Nothing said which language. One claimant is an answer; several are not.
   const claims: { port: string; decision: MentionDecision }[] = []
diff --git a/packages/api-model/src/resolver.ts b/packages/api-model/src/resolver.ts
index 95d63849..b6f4d6fc 100644
--- a/packages/api-model/src/resolver.ts
+++ b/packages/api-model/src/resolver.ts
@@ -267,6 +267,11 @@ export class Resolver {
 
     const member = parts[parts.length - 1]
     const candidates = Resolver.preferTypeOverConstructor(this.members(port, member))
+    if (parts.length > 2) {
+      const suffix = `.${parts.join('.')}`
+      const qualified = candidates.filter((row) => `.${toPath(row.qualified).join('.')}`.endsWith(suffix))
+      if (qualified.length === 1) return { how: 'scoped', symbol: qualified[0].symbol, port }
+    }
     if (candidates.length === 1) return { how: 'unique', symbol: candidates[0].symbol, port }
     let local = Resolver.preferProduct(candidates, product)
     if (parts.length === 1) {
diff --git a/packages/api-model/test/prose-audit.test.ts b/packages/api-model/test/prose-audit.test.ts
index 710ad642..a8da1a02 100644
--- a/packages/api-model/test/prose-audit.test.ts
+++ b/packages/api-model/test/prose-audit.test.ts
@@ -68,8 +68,26 @@ describe('product context in prose', () => {
 
   it('does not borrow another language when the page already names its port', () => {
     const other = { port: 'py', version: '0', symbols: [{ id: 'Other', name: 'Other', kind: 'class', signatures: [] }] } as ApiModel
-    const result = decideMention('Other', { pagePort: 'go', product: 'workspace' }, new Resolver([model, other]), { go: model, py: other })
-    expect(result.kind).toBe('unresolved')
+    for (const product of [undefined, 'workspace'] as const) {
+      const result = decideMention('Other', { pagePort: 'go', product }, new Resolver([model, other]), { go: model, py: other })
+      expect(result.kind).toBe('unresolved')
+    }
+  })
+
+  it('links standard-library types through the existing language catalog', () => {
+    const rust = { port: 'rs', version: '0', symbols: [] } as unknown as ApiModel
+    expect(decideMention('BTreeMap', { pagePort: 'rs' }, new Resolver([rust]), { rs: rust }))
+      .toMatchObject({ kind: 'link', port: 'rs', href: 'https://doc.rust-lang.org/std/collections/struct.BTreeMap.html', external: true })
+  })
+
+  it('uses the enclosing type to distinguish nested builders', () => {
+    const java = { port: 'java', version: '0', symbols: ['SessionSpec', 'WindowSpec'].map((name) => ({
+      id: `io.example.${name}.${name}.Builder.environment`, name: 'environment', kind: 'method', signatures: [],
+    })) } as unknown as ApiModel
+    const r = new Resolver([java])
+    const found = r.resolve('java', 'SessionSpec.Builder.environment(Map)')
+    expect('symbol' in found && found.symbol.id).toBe('io.example.SessionSpec.SessionSpec.Builder.environment')
+    expect(r.resolve('java', 'Builder.environment(Map)').how).toBe('ambiguous')
   })
 
   it('classifies MCP resource URIs and newly authored filenames explicitly', () => {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b912787d..8a8b696c 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -199,6 +199,15 @@ importers:
       '@biomejs/biome':
         specifier: 'catalog:'
         version: 2.5.14
+      happy-dom:
+        specifier: 'catalog:'
+        version: 20.14.5
+      mdast-util-from-markdown:
+        specifier: 2.0.3
+        version: 2.0.3
+      mdast-util-to-markdown:
+        specifier: 2.1.2
+        version: 2.1.2
       oxlint:
         specifier: 'catalog:'
         version: 1.85.0(oxlint-tsgolint@7.0.2002)
diff --git a/scripts/build-site.sh b/scripts/build-site.sh
index b1f08c75..0544beff 100755
--- a/scripts/build-site.sh
+++ b/scripts/build-site.sh
@@ -295,11 +295,10 @@ if [ -n "${LIBTMUX_DOCS_SOURCE_SHA:-}" ] || [ -n "${LIBTMUX_DOCS_SOURCE_REF:-}"
   [ "$source_resolved" = "$LIBTMUX_DOCS_SOURCE_SHA" ] || die "source ref resolves to $source_resolved, expected $LIBTMUX_DOCS_SOURCE_SHA"
 fi
 
-# Source-owned guides are ephemeral build input. Always clear the staging
-# tree first so a guide removed on a branch cannot survive from an earlier
-# build. Exact port callers must have their native artifact; a full local
-# assembly stages both new ports only when both artifacts are present.
+# Ordinary builds use committed, revision-bound guides. A selected source
+# replaces only its port's guides after native artifact validation.
 rm -rf "$site_dir/src/content/docs/_staged"
+node "$script_dir/stage-port-docs.mjs" --cached
 if [ -n "${LIBTMUX_DOCS_PORT:-}" ] && { [ "$LIBTMUX_DOCS_PORT" = ruby ] || [ "$LIBTMUX_DOCS_PORT" = lua ]; }; then
   node "$script_dir/gen-api-model.mjs" --port "$LIBTMUX_DOCS_PORT"
   node "$script_dir/stage-port-docs.mjs" --port "$LIBTMUX_DOCS_PORT"
@@ -314,15 +313,7 @@ elif [ -n "${LIBTMUX_DOCS_SOURCE_SHA:-}" ]; then
   # last refreshed. The generator re-checks the SHA and records it.
   node "$script_dir/gen-api-model.mjs" --port "$LIBTMUX_DOCS_PORT"
   node "$script_dir/gen-api-model.mjs" --port "$LIBTMUX_DOCS_PORT" --nav
-elif [ -f "${LIBTMUX_DOCS_CHECKOUT_RUBY:-$HOME/work/libtmux/libtmux-ruby-docs}/docs/_build/api.json" ] &&
-     [ -f "${LIBTMUX_DOCS_CHECKOUT_LUA:-$HOME/work/libtmux/libtmux-lua-docs}/docs/_build/api.json" ]; then
-  node "$script_dir/gen-api-model.mjs" --port ruby
-  node "$script_dir/gen-api-model.mjs" --port lua
-  node "$script_dir/stage-port-docs.mjs"
-elif [ -n "${LIBTMUX_DOCS_CHECKOUT_RUBY:-}" ] && [ -n "${LIBTMUX_DOCS_CHECKOUT_LUA:-}" ]; then
-  node "$script_dir/stage-port-docs.mjs" --from-source
 fi
-node "$script_dir/stage-port-docs.mjs" --wrappers
 node "$script_dir/gen-example-sources.mjs"
 node "$script_dir/gen-mentions.mjs"
 
@@ -1076,7 +1067,9 @@ while IFS='|' read -r slug name versioned renderer generator checkout ecosystem_
     if [ "$ref_status" = "built" ]; then
       mkdir -p "$port_out/api"
       cp -a "$ref_outdir/." "$port_out/api/"
-      node "$script_dir/normalize-native-shell.mjs" "$port_out/api" "$LIBTMUX_DOCS_PORT_ROOT"
+      native_shell_args=()
+      if [ "$renderer" = sphinx ]; then native_shell_args+=("$slug" "$version"); fi
+      node "$script_dir/normalize-native-shell.mjs" "$port_out/api" "$LIBTMUX_DOCS_PORT_ROOT" "${native_shell_args[@]}"
       node "$script_dir/brand-native-pages.mjs" "$port_out/api" "$slug" "$LIBTMUX_DOCS_PORT_ROOT"
     elif [ "$ref_status" = "skipped" ]; then
       mkdir -p "$port_out/api"
diff --git a/scripts/check-api-links.mjs b/scripts/check-api-links.mjs
index 76e02953..f7ab5f3f 100755
--- a/scripts/check-api-links.mjs
+++ b/scripts/check-api-links.mjs
@@ -24,7 +24,7 @@ import { Resolver, decideFilePath, decideMention, isLikelyReference, looksLikeAp
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
 const { API_MODEL_PORTS: PORT_DEFS, PORT_BY_SLUG } = await import(`file://${resolve(root, 'site/src/lib/ports.ts')}`)
 const PORTS = PORT_DEFS.map((p) => p.slug)
-const { KNOWN_PORTS, resolvePortBody } = await import(`file://${resolve(root, 'site/src/lib/workspace-shared-slots.ts')}`)
+const { KNOWN_PORTS, resolvePortBody, resolvePortContent } = await import(`file://${resolve(root, 'site/src/lib/workspace-shared-slots.ts')}`)
 const SHARED = join(root, 'site/src/content/_workspace-shared')
 const CONTENT = join(root, 'site/src/content/docs')
 const started = Date.now()
@@ -157,9 +157,10 @@ for (const file of targets) {
   if (PORT_BY_SLUG[authoredPort]?.referenceKind === 'guide') continue
   const product = /^product:\s*['"]?(core|workspace|mcp)['"]?\s*$/m.exec(frontmatter)?.[1]
     ?? /^ports\/[^/]+\/(workspace|mcp)\//.exec(file.replace(`${CONTENT}/`, ''))?.[1]
-  for (const { text, port: ctxPort, before, line, linked } of proseMentions(raw, PORT_BY_LABEL)) {
+  const selected = resolvePortContent(raw, authoredPort)
+  for (const { text, port: ctxPort, before, line, linked } of proseMentions(selected.body, PORT_BY_LABEL, selected.portAt)) {
     if (linked) { tally.alreadyLinked++; continue }
-    const pagePort = ctxPort ?? authoredPort
+    const pagePort = authoredPort ?? ctxPort
 
     if (FILE_RE.test(text) || text.endsWith('/')) {
       const d = decideFilePath(text, { before, pagePort }, trees)
@@ -175,17 +176,14 @@ for (const file of targets) {
     if (notASymbol(text) || !looksLikeApiMention(text)) { tally.notASymbol++; continue }
 
 
-    const linkable = (authoredPort ? [pagePort] : [ctxPort, ...PORTS]).some((port) => {
-      if (!port) return false
-      const decision = decideMention(text, { pagePort: port, product, before }, resolver, models)
-      return decision.kind === 'link'
-    })
+    const decisions = (pagePort ? [pagePort] : PORTS)
+      .map((port) => decideMention(text, { pagePort: port, product, before }, resolver, models))
     // `notApiReason` gates *reporting*, not linking — exactly as the plugin
     // does. A span it names still gets offered to the resolver, because a
     // `TMUX_TMPDIR` that happens to resolve is a link worth having; it simply
     // is not a dangling reference when it does not.
-    if (linkable) tally.willLink++
-    else if (!isLikelyReference(text) || notApiReason(text) || EXCEPTIONS.has(text)) tally.notASymbol++
+    if (decisions.some((decision) => decision.kind === 'link')) tally.willLink++
+    else if (decisions.some((decision) => decision.kind === 'skip') || !isLikelyReference(text) || notApiReason(text) || EXCEPTIONS.has(text)) tally.notASymbol++
     else { tally.unresolved++; unresolved.push({ file, line, text }) }
   }
 }
diff --git a/scripts/check-go-prose.py b/scripts/check-go-prose.py
new file mode 100644
index 00000000..abbc3af1
--- /dev/null
+++ b/scripts/check-go-prose.py
@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Compile and run eight shared Go examples on isolated tmux servers.
+
+Usage: python3 scripts/check-go-prose.py --checkout PATH [--ref REF]
+The default ref is the source revision in the integrated Go API model.
+This is an optional native verification gate; it needs Go and tmux on PATH.
+"""
+from pathlib import Path
+import argparse
+import json
+import os
+import re
+import subprocess
+import tempfile
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument('--checkout', type=Path, required=True)
+parser.add_argument('--ref')
+args = parser.parse_args()
+repo = Path(__file__).resolve().parent.parent
+model = json.loads((repo / 'site/src/data/api/go.json').read_text())
+revision = subprocess.check_output(
+    ['git', '-C', str(args.checkout), 'rev-parse', (args.ref or model['revision']) + '^{commit}'], text=True
+).strip()
+root = repo / 'site/src/content/docs/topics'
+
+def verify(root, out, source, revision):
+    go_version = re.search(r'^go (.+)$', (source / 'go.mod').read_text(), re.M).group(1)
+    (out / 'go.mod').write_text(
+        f'module docs-check\n\ngo {go_version}\n\n'
+        'require github.com/libtmux/libtmux-go v0.0.0\n\n'
+        f'replace github.com/libtmux/libtmux-go => {source.resolve()}\n'
+    )
+    parts=['''package docscheck
+    import (
+        "context"
+        "errors"
+        "fmt"
+        "testing"
+        "os"
+        "time"
+        "github.com/libtmux/libtmux-go/tmux"
+        "github.com/libtmux/libtmux-go/tmux/tmuxtest"
+    )
+    ''']
+    givens={'pane-interaction':['pane tmux.Pane','pane tmux.Pane'], 'options-and-hooks':['window tmux.Window','session tmux.Session'], 'waiting-and-retry':['session tmux.Session','server tmux.Server']}
+    for name in [*givens, 'context-managers']:
+        matches = list(re.finditer(r'^```go[^\n]*\n(.*?)^```', (root/(name+'.md')).read_text(), re.M|re.S))
+        assert len(matches) == (1 if name == 'context-managers' else 2), f'Update verification for changed {name} examples'
+        for index, match in enumerate(matches):
+            code=match[1]
+            if name=='context-managers':parts.append(code);continue
+            fn=name.replace('-','')+str(index)
+            parts.append('func '+fn+'(ctx context.Context, '+givens[name][index]+') error {\n'+code+'\nreturn nil\n}\n')
+    transports = list(re.finditer(r'^```go[^\n]*\n(.*?)^```',
+        (root.parent/'concepts/transports.md').read_text(), re.M|re.S))
+    assert len(transports) == 1, 'Update verification for changed transport examples'
+    parts.append('func transportExample() error {\n'+transports[0][1]+'\n}\n')
+    parts.append('''
+    func TestMain(m *testing.M) { os.Exit(tmuxtest.Main(m)) }
+
+    func TestTransportExample(t *testing.T) {
+        ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
+        defer cancel()
+        server := tmuxtest.NewServerWithOptions(ctx, t, tmuxtest.ServerOptions{FixedShell: true})
+        t.Setenv("TMUX", server.SocketPath()+",0,0")
+        if err := transportExample(); err != nil { t.Fatal(err) }
+        filter := tmux.TmuxFilter("#{==:#{session_name},work}")
+        sessions, err := server.SearchSessions(ctx, &filter)
+        if err != nil || len(sessions) != 1 { t.Fatalf("created session: %v, %v", sessions, err) }
+        panes, err := sessions[0].SearchPanes(ctx, nil)
+        if err != nil || len(panes) != 1 { t.Fatalf("created pane: %v, %v", panes, err) }
+        tmuxtest.WaitForLine(ctx, t, panes[0], "hello")
+    }
+
+    func TestPublishedExamples(t *testing.T) {
+        ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
+        defer cancel()
+        server := tmuxtest.NewServerWithOptions(ctx, t, tmuxtest.ServerOptions{Config: []byte("set-window-option -g automatic-rename off\\n"), FixedShell: true})
+        session := tmuxtest.NewSession(ctx, t, server, tmux.NewSessionRequest{})
+        name := "build"
+        window := tmuxtest.NewWindow(ctx, t, session, tmux.NewWindowRequest{Name: &name})
+        panes, err := window.SearchPanes(ctx, nil)
+        if err != nil || len(panes) != 1 { t.Fatalf("setup panes: %v, %v", panes, err) }
+        pane := panes[0]
+        calls := []struct { name string; run func() error }{
+            {"send", func() error { return paneinteraction0(ctx, pane) }},
+            {"capture", func() error { return paneinteraction1(ctx, pane) }},
+            {"options", func() error { return optionsandhooks0(ctx, window) }},
+            {"hooks", func() error { return optionsandhooks1(ctx, session) }},
+            {"poll", func() error { return waitingandretry0(ctx, session) }},
+            {"channel", func() error { return waitingandretry1(ctx, server) }},
+            {"cleanup", func() error { return temporarySession(ctx, server) }},
+        }
+        for _, call := range calls {t.Run(call.name, func(t *testing.T) {
+            if err := call.run(); err != nil { t.Fatal(err) }
+        })}
+        if err := tmuxtest.WaitFor(ctx, 10*time.Millisecond, func(ctx context.Context) (bool, error) {
+            lines, err := pane.Capture(ctx, tmux.CapturePaneRequest{})
+            for _, line := range lines { if line == "hello" { return true, err } }
+            return false, err
+        }); err != nil { t.Fatalf("literal input did not execute: %v", err) }
+        if err := paneinteraction0(ctx, tmux.Pane{}); err == nil { t.Fatal("invalid pane error was swallowed") }
+        expired, stop := context.WithCancel(ctx); stop()
+        if err := waitingandretry0(expired, session); !errors.Is(err, context.Canceled) {t.Fatalf("cancellation lost: %v", err)}
+        sessions, err := server.Sessions(ctx)
+        if err != nil || len(sessions) != 1 || sessions[0].ID() != session.ID() {t.Fatalf("owned cleanup changed sessions: %v, %v", sessions, err)}
+    }
+    ''')
+    (out/'examples_test.go').write_text('\n'.join(parts))
+
+    env = {key: value for key, value in os.environ.items() if key not in ['TMUX', 'TMUX_PANE', 'GOWORK']}
+    env['GOWORK'] = 'off'
+    env['TMUX_TMPDIR'] = str(out)
+    print(f'Go prose: {revision}; eight examples from five pages', flush=True)
+    subprocess.run(['go', 'test', '-count=1', '-v', '.'], cwd=out, env=env, check=True)
+
+with tempfile.TemporaryDirectory(prefix='libtmux-go-prose-') as temporary:
+    out = Path(temporary)
+    source = out / 'source'
+    source.mkdir()
+    archive = subprocess.check_output(['git', '-C', str(args.checkout), 'archive', revision])
+    subprocess.run(['tar', '-xf', '-', '-C', str(source)], input=archive, check=True)
+    verify(root, out, source, revision)
diff --git a/scripts/check-workspace-prose.py b/scripts/check-workspace-prose.py
new file mode 100644
index 00000000..3276e762
--- /dev/null
+++ b/scripts/check-workspace-prose.py
@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""Run native workspace CLI examples and failure checks on a private tmux socket.
+
+Build the CLI from the source revision cited by the pages first. This runner
+checks the supplied executable; it does not establish its build provenance.
+Usage: python3 scripts/check-workspace-prose.py --port go --binary /path/to/tmux-workspace
+Node, tmux and the CLI runtime must be on PATH. --report saves the run results.
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import pathlib
+import re
+import shutil
+import subprocess
+import tempfile
+import time
+
+ROOT = pathlib.Path(__file__).resolve().parent.parent
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument(
+    "--port",
+    choices=["ts", "rs", "go", "java", "dotnet", "cxx", "swift"],
+    required=True,
+)
+parser.add_argument("--binary", required=True, type=pathlib.Path)
+parser.add_argument("--report", type=pathlib.Path)
+args = parser.parse_args()
+BINARY = args.binary.resolve()
+NODE = shutil.which("node") or parser.error("node is required")
+TMUX = shutil.which("tmux") or parser.error("tmux is required")
+PAGES = [
+    "cli/" + name
+    for name in [
+        "index",
+        "convert",
+        "edit",
+        "freeze",
+        "ls",
+        "debug-info",
+        "search",
+        "load",
+        "import",
+        "import-teamocil",
+        "import-tmuxinator",
+        "completion",
+    ]
+]
+if os.environ.get("TMUX_WORKSPACE_PYTHON"):
+    PAGES.append("cli/shell")
+CONFIGURATIONS = [
+    "index",
+    "session",
+    "windows",
+    "panes",
+    "commands",
+    "directories",
+    "environment",
+    "layouts",
+    "hooks",
+]
+PAGES.extend("configuration/" + name for name in CONFIGURATIONS)
+PAGES.extend(
+    [
+        "guides/discovery",
+        "guides/automation",
+        "guides/export-session",
+        "guides/troubleshooting",
+        "reference/output",
+        "examples/gallery",
+    ]
+)
+extract = """import {readFileSync} from 'node:fs';
+import {resolvePortBody} from './site/src/lib/workspace-shared-slots.ts';
+const pages=JSON.parse(process.argv[1]);
+console.log(JSON.stringify(Object.fromEntries(pages.map(name=>[name,resolvePortBody(readFileSync('site/src/content/_workspace-shared/workspace/'+name+'.md','utf8'),process.argv[2])]))));
+"""
+bodies = json.loads(
+    subprocess.check_output(
+        [NODE, "--input-type=module", "-e", extract, json.dumps(PAGES), args.port],
+        cwd=ROOT,
+        text=True,
+    )
+)
+evidence = {
+    "port": args.port,
+    "binary": str(BINARY),
+    "entrypoint_sha256": hashlib.sha256(BINARY.read_bytes()).hexdigest(),
+    "pages": {
+        name: hashlib.sha256(body.encode()).hexdigest() for name, body in bodies.items()
+    },
+    "positive": [],
+    "negative": [],
+    "skipped": []
+    if "cli/shell" in PAGES
+    else ["shell: set TMUX_WORKSPACE_PYTHON to a compatible runtime"],
+}
+# Unix sockets require the Linux filesystem when running under WSL.
+fixture_root = (
+    pathlib.Path(tempfile.gettempdir())
+    if args.port == "ts"
+    else pathlib.Path(f"/tmp/libtmux-{args.port}-test")
+)
+fixture_root.mkdir(exist_ok=True)
+with tempfile.TemporaryDirectory(
+    prefix="ltx-doc-" if args.port == "ts" else "docs-", dir=fixture_root
+) as directory:
+    here = pathlib.Path(directory)
+    socket = here / "tmux.sock"
+    bindir = here / "bin"
+    bindir.mkdir()
+    (bindir / "tmux-workspace").symlink_to(BINARY)
+    editor = bindir / "vi"
+    editor.write_text(
+        '#!/bin/sh\n[ -f "$1" ] || exit 42\nprintf "%s" "$1" > "$WORKSPACE_TMP/editor-argument"\n'
+    )
+    editor.chmod(0o755)
+    configs = here / "config"
+    configs.mkdir()
+    doc = "session_name: workspace-guide\nwindows:\n  - window_name: editor\n    layout: even-horizontal\n    panes:\n      - printf ready\n      - printf second\n"
+    (here / "workspace.yaml").write_text(doc)
+    (configs / "workspace.yaml").write_text(doc)
+    for body in bodies.values():
+        for match in re.finditer(
+            r'```(?:yaml|json) title="([\w.-]+)"\n(.*?)\n```', body, re.S
+        ):
+            (here / match[1]).write_text(match[2] + "\n")
+    env = dict(
+        os.environ,
+        PATH=f"{bindir}{os.pathsep}{os.environ.get('PATH', '')}",
+        WORKSPACE_TMP=str(here),
+        TMUXP_CONFIGDIR=str(configs),
+        XDG_CONFIG_HOME=str(configs),
+        TMUX_TMPDIR=str(here),
+        SHELL="/bin/sh",
+        ENV="/dev/null",
+        BASH_ENV="/dev/null",
+        ZDOTDIR=str(here),
+    )
+    env.pop("TMUX", None)
+    env.pop("TMUX_PANE", None)
+    env.pop("VISUAL", None)
+    for name in ["DOC_SESSION", "DOC_WINDOW", "DOC_PANE"]:
+        env.pop(name, None)
+
+    def run(command, success=True):
+        result = subprocess.run(
+            command,
+            cwd=here,
+            env=env,
+            text=True,
+            capture_output=True,
+            timeout=30,
+            shell=isinstance(command, str),
+        )
+        if success and result.returncode:
+            raise AssertionError((command, result.returncode, result.stderr[-1500:]))
+        if not success and not result.returncode:
+            raise AssertionError(("expected failure", command))
+        return result
+
+    try:
+        run(
+            [
+                str(BINARY),
+                "load",
+                "-S",
+                str(socket),
+                "-f",
+                "/dev/null",
+                "-d",
+                "--json",
+                "workspace.yaml",
+            ]
+        )
+        for name, body in bodies.items():
+            for match in re.finditer(r"```console\n(.*?)\n```", body, re.S):
+                command = match[1].removeprefix("$ ")
+                result = run(command)
+                if "--json" in command:
+                    json.loads(result.stdout)
+                elif "--ndjson" in command:
+                    for line in result.stdout.splitlines():
+                        json.loads(line)
+                evidence["positive"].append(
+                    {"page": name, "command": command, "exit": result.returncode}
+                )
+        for name in CONFIGURATIONS:
+            body = bodies["configuration/" + name]
+            document = re.search(r'```yaml title="([\w.-]+)"\n(.*?)\n```', body, re.S)
+            assert document, name
+            result = run(
+                [str(BINARY), "load", "-S", str(socket), "-d", "--json", document[1]]
+            )
+            json.loads(result.stdout)
+            evidence["positive"].append(
+                {
+                    "page": "configuration/" + name,
+                    "document": document[1],
+                    "exit": result.returncode,
+                }
+            )
+
+        for document in ["gallery-blank.yaml", "gallery-commands.yaml"]:
+            result = run(
+                [str(BINARY), "load", "-S", str(socket), "-d", "--json", document]
+            )
+            json.loads(result.stdout)
+            evidence["positive"].append(
+                {
+                    "page": "examples/gallery",
+                    "document": document,
+                    "exit": result.returncode,
+                }
+            )
+
+        def tmux(*command):
+            return run([TMUX, "-S", str(socket), *command]).stdout.strip()
+
+        expected_panes = {
+            "configuration-example": 2,
+            "session-example": 1,
+            "windows-example": 2,
+            "panes-example": 2,
+            "commands-example": 1,
+            "directories-example": 1,
+            "environment-example": 2,
+            "layouts-example": 3,
+            "hooks-example": 1,
+        }
+        for session, count in expected_panes.items():
+            panes = tmux(
+                "list-panes", "-s", "-t", "=" + session, "-F", "#{pane_id}"
+            ).splitlines()
+            assert len(panes) == count, (session, panes)
+        session_ids = dict(
+            line.split("\t")
+            for line in tmux(
+                "list-sessions", "-F", "#{session_name}\t#{session_id}"
+            ).splitlines()
+        )
+        assert (
+            tmux("show-options", "-v", "-t", session_ids["session-example"], "status")
+            == "off"
+        )
+        assert (
+            tmux(
+                "show-window-options",
+                "-v",
+                "-t",
+                tmux(
+                    "list-windows",
+                    "-t",
+                    session_ids["windows-example"],
+                    "-F",
+                    "#{window_id}",
+                ),
+                "synchronize-panes",
+            )
+            == "on"
+        )
+        assert (
+            tmux("list-windows", "-t", "=windows-example", "-F", "#{window_index}")
+            == "2"
+        )
+        assert tmux(
+            "list-panes", "-t", "=panes-example:work", "-F", "#{pane_active}"
+        ).splitlines() == ["0", "1"]
+        assert tmux(
+            "display-message",
+            "-p",
+            "-t",
+            "=directories-example:shell",
+            "#{pane_current_path}",
+        ) == str(here)
+        environment_panes = tmux(
+            "list-panes", "-t", "=environment-example:shell", "-F", "#{pane_id}"
+        ).splitlines()
+
+        def await_text(pane, expected):
+            deadline = time.monotonic() + 3
+            while True:
+                output = tmux("capture-pane", "-p", "-t", pane)
+                if expected in output:
+                    return output
+                if time.monotonic() >= deadline:
+                    raise AssertionError((args.port, pane, expected, output))
+                time.sleep(0.02)
+
+        for pane, expected in zip(
+            environment_panes, ["ENV=session||pane", "ENV=session|window|"], strict=True
+        ):
+            await_text(pane, expected)
+        synchronized = tmux(
+            "list-panes", "-t", "=windows-example:tools", "-F", "#{pane_id}"
+        ).splitlines()
+        assert "right" not in await_text(synchronized[0], "left")
+        assert "left" not in await_text(synchronized[1], "right")
+        evidence["configuration_checks"] = [
+            "pane counts",
+            "session options",
+            "option timing",
+            "window index",
+            "pane focus",
+            "working directory",
+            "launch environment",
+        ]
+        assert (here / "workspace.json").is_file()
+        assert (here / "captured-workspace.yaml").is_file()
+        assert (here / "editor-argument").read_text().endswith("workspace.yaml")
+        before = (here / "workspace.json").read_bytes()
+        failed = run(
+            [
+                str(BINARY),
+                "convert",
+                "--json",
+                "--workspace-format",
+                "json",
+                "--save-to",
+                "workspace.json",
+                "workspace.yaml",
+            ],
+            False,
+        )
+        assert before == (here / "workspace.json").read_bytes()
+        evidence["negative"].append(
+            {"case": "existing destination preserved", "exit": failed.returncode}
+        )
+        editor.write_text("#!/bin/sh\nexit 17\n")
+        failed = run("EDITOR=vi tmux-workspace edit workspace.yaml", False)
+        assert failed.returncode == 17
+        evidence["negative"].append(
+            {"case": "editor status propagated", "exit": failed.returncode}
+        )
+        failed = run([str(BINARY), "search", "--json", "["], False)
+        evidence["negative"].append(
+            {"case": "invalid regex fails", "exit": failed.returncode}
+        )
+        (here / "invalid.yaml").write_text(
+            "session_name: invalid\nbogus: true\nwindows: [{window_name: shell, panes: [null]}]\n"
+        )
+        failed = run(
+            [str(BINARY), "load", "-S", str(socket), "-d", "--json", "invalid.yaml"],
+            False,
+        )
+        evidence["negative"].append(
+            {"case": "invalid workspace fails", "exit": failed.returncode}
+        )
+    finally:
+        if socket.exists():
+            subprocess.run(
+                [TMUX, "-S", str(socket), "kill-server"],
+                capture_output=True,
+                check=True,
+            )
+if args.report:
+    args.report.write_text(json.dumps(evidence, indent=2) + "\n")
+print(
+    f"PASS: {len(evidence['positive'])} documented commands, {len(evidence['negative'])} failure checks for {args.port}"
+)
+for skipped in evidence["skipped"]:
+    print(f"SKIPPED: {skipped}")
diff --git a/scripts/gen-example-sources.mjs b/scripts/gen-example-sources.mjs
index 26e7940e..0482b9a7 100755
--- a/scripts/gen-example-sources.mjs
+++ b/scripts/gen-example-sources.mjs
@@ -1,35 +1,9 @@
 #!/usr/bin/env node
-/**
- * Cache the example sources that prose inlines, so a build needs no port
- * checkouts.
- *
- * `remark-port-code.mjs` turns a fence like
- *
- *     ```typescript file="examples/quickstart/quickstart.ts"
- *
- * into the real contents of that file, read out of the port's own checkout.
- * That is the point: the code on the page is the code the port tests, and a
- * missing source fails the build rather than shipping an empty fence.
- *
- * It also means the build cannot run anywhere the eight checkouts are absent,
- * which is every CI runner. This writes what those fences resolve to into a
- * committed file, exactly as `gen-api-model.mjs` does for the extracted
- * models and for the same reason — CI builds from committed data, and
- * `--check` is what stops that data rotting, since nothing else compares it
- * against the source it came from.
- *
- * Whole files are cached, not the sliced regions: `sliceRegion` stays the one
- * implementation, so a cached read and a live read cannot disagree about what
- * a region means.
- *
- * Usage:
- *   node scripts/gen-example-sources.mjs             # rewrite the cache
- *   node scripts/gen-example-sources.mjs --check     # fail if it is stale
- *   node scripts/gen-example-sources.mjs --out PATH  # a fixture, for the
- *                                                    # negative test
- */
+/** Cache example files at the exact revision recorded by each port's documentation. */
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
 import { fileURLToPath } from 'node:url'
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
@@ -76,45 +50,43 @@ for (const md of markdownFiles(CONTENT)) {
   }
 }
 
-const cache = {}
-const missing = []
-for (const [key, { owner, file }] of [...wanted].sort((a, b) => a[0].localeCompare(b[0]))) {
-  const checkout = checkoutFor(owner)
-  const abs = join(checkout, file)
-  if (!existsSync(abs)) {
-    missing.push(`${key} (looked in ${checkout})`)
-    continue
-  }
-  cache[key] = readFileSync(abs, 'utf8')
-}
+const digest = (content) => createHash('sha256').update(content).digest('hex')
 
-const current = existsSync(OUT) ? readFileSync(OUT, 'utf8') : ''
-
-/*
- * A checkout that is not here cannot be read, and its cached entry cannot be
- * confirmed either way. Reported rather than treated as agreement: silence
- * would read as "verified" on a machine that verified nothing.
- */
-if (missing.length) {
-  console.error(`gen-example-sources: ${missing.length} source(s) unreadable — checkout absent:`)
-  for (const m of missing) console.error(`  ${m}`)
-  const kept = missing.filter((m) => Object.hasOwn(JSON.parse(current || '{}'), m.split(' ')[0]))
-  if (kept.length) {
-    console.error(`  ${kept.length} of these are in the cache already; keeping the cached copy.`)
-    for (const m of kept) cache[m.split(' ')[0]] = JSON.parse(current)[m.split(' ')[0]]
+/** Read committed bytes; a working tree can be dirty or on a different branch. */
+export function cachedExample({ repository, revision, file, checkout, current }) {
+  if (!/^[a-f0-9]{40}$/.test(revision)) throw new Error(`Invalid example revision: ${revision}`)
+  if (existsSync(join(checkout, '.git'))) {
+    const content = execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`],
+      { encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] })
+    return { repository, revision, sha256: digest(content), content }
+  }
+  if (current?.repository !== repository || current?.revision !== revision ||
+      typeof current.content !== 'string' || current.sha256 !== digest(current.content)) {
+    throw new Error(`${repository}:${file}: no verified cache for ${revision}; provide its checkout and regenerate example sources`)
   }
+  return current
 }
 
-const merged = `${JSON.stringify(Object.fromEntries(Object.entries(cache).sort()), null, 2)}\n`
-
-if (check) {
-  if (merged !== current) {
-    console.error(`\ngen-example-sources: ${OUT.replace(`${root}/`, '')} is stale. Rerun:`)
-    console.error('  node scripts/gen-example-sources.mjs')
-    process.exit(1)
+export function run() {
+  const current = existsSync(OUT) ? readFileSync(OUT, 'utf8') : ''
+  const previous = JSON.parse(current || '{}')
+  const cache = {}
+  const offline = new Set()
+  for (const [key, { owner, file }] of [...wanted].sort((a, b) => a[0].localeCompare(b[0]))) {
+    const modelPath = join(root, `site/src/data/api/${owner}.json`)
+    const provenance = existsSync(modelPath) ? JSON.parse(readFileSync(modelPath, 'utf8'))
+      : JSON.parse(readFileSync(join(root, `site/src/data/port-guides/${owner}.json`), 'utf8')).source
+    const repository = provenance.repository ?? provenance.repo
+    const revision = provenance.revision
+    const checkout = checkoutFor(owner)
+    if (!existsSync(join(checkout, '.git'))) offline.add(owner)
+    cache[key] = cachedExample({ repository, revision, file, checkout, current: previous[key] })
   }
-  console.log(`gen-example-sources: cache matches ${Object.keys(cache).length} example source(s)`)
-} else {
-  writeFileSync(OUT, merged)
-  console.log(`gen-example-sources: wrote ${Object.keys(cache).length} example source(s) to ${OUT.replace(`${root}/`, '')}`)
+  const merged = `${JSON.stringify(cache, null, 2)}\n`
+  if (check && merged !== current) throw new Error(`${OUT}: stale example sources; run node scripts/gen-example-sources.mjs`)
+  if (!check) writeFileSync(OUT, merged)
+  console.log(`gen-example-sources: ${check ? 'cache matches' : 'wrote'} ${Object.keys(cache).length} revision-bound example sources`)
+  if (offline.size) console.log(`gen-example-sources: cached sources for ${[...offline].join(', ')}; checksums and revisions checked, source checkouts unavailable`)
 }
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) run()
diff --git a/scripts/gen-example-sources.negative.mjs b/scripts/gen-example-sources.negative.mjs
index ac9f66b3..971155a2 100755
--- a/scripts/gen-example-sources.negative.mjs
+++ b/scripts/gen-example-sources.negative.mjs
@@ -1,98 +1,38 @@
 #!/usr/bin/env node
-/*
- * Proof that `gen-example-sources.mjs --check` fails on a stale cache.
- *
- * The control is a freshly generated fixture, because a check that always
- * failed would satisfy the drift case on its own.
- *
- * Two ways to be stale are tested, because they are different failures. An
- * edited source is the everyday one: a port changes the example it tests and
- * the committed copy still shows the old code, which is the drift the cache
- * exists to make visible rather than to hide. A dropped entry is the one that
- * would break a build rather than mislead a reader — `readFence` throws when
- * a source is in neither the checkout nor the cache.
- */
-import { mkdirSync, mkdtempSync, readFileSync, writeFileSync, rmSync } from 'node:fs'
+/** Exercise revision binding and deliberately damaged example caches. */
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
-import { join, dirname } from 'node:path'
+import { join } from 'node:path'
 import { execFileSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-import { CHECKOUTS } from '../site/src/plugins/remark-port-code.mjs'
-import sources from '../site/src/data/example-sources.json' with { type: 'json' }
-
-const script = join(dirname(fileURLToPath(import.meta.url)), 'gen-example-sources.mjs')
-
-function run(args) {
-  try {
-    return { code: 0, out: execFileSync('node', [script, ...args], { encoding: 'utf8', stdio: 'pipe', env }) }
-  } catch (err) {
-    return { code: err.status, out: `${err.stdout ?? ''}${err.stderr ?? ''}` }
-  }
-}
-
-const dir = mkdtempSync(join(tmpdir(), 'gen-example-sources-'))
-const fixture = join(dir, 'cache.json')
-const env = { ...process.env }
-for (const port of Object.keys(CHECKOUTS)) env[`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}`] = join(dir, port)
-const sample = Object.keys(sources).sort()[0]
-const sampleText = '// isolated example source\n'
-for (const [key, text] of Object.entries(sources)) {
-  const [port, file] = key.split(':')
-  const path = join(dir, port, file)
-  mkdirSync(dirname(path), { recursive: true })
-  writeFileSync(path, key === sample ? sampleText : text)
-}
-process.on('exit', () => rmSync(dir, { recursive: true, force: true }))
-
-let failures = 0
-const check = (name, ok, detail) => {
-  if (ok) console.log(`ok   ${name}`)
-  else {
-    console.error(`FAIL ${name} — ${detail}`)
-    failures += 1
-  }
-}
-
-const generated = run(['--out', fixture])
-if (generated.code !== 0) {
-  console.error(`FAIL could not generate a control fixture — ${generated.out}`)
-  process.exit(1)
-}
-const pristine = readFileSync(fixture, 'utf8')
-if (JSON.parse(pristine)[sample] !== sampleText) throw new Error('Generator ignored the fixture checkout')
-
-{
-  const res = run(['--check', '--out', fixture])
-  check('a freshly generated cache passes', res.code === 0 && /matches/.test(res.out), `exit ${res.code}: ${res.out.trim()}`)
-}
-
-const mutations = [
-  [
-    'an edited source is caught',
-    (d) => {
-      const k = Object.keys(d).sort()[0]
-      return { ...d, [k]: `${d[k]}\n// drifted\n` }
-    },
-  ],
-  [
-    'a dropped entry is caught',
-    (d) => {
-      const { [Object.keys(d).sort()[0]]: _gone, ...rest } = d
-      return rest
-    },
-  ],
-]
-
-for (const [name, mutate] of mutations) {
-  const before = JSON.parse(pristine)
-  const after = mutate(before)
-  writeFileSync(fixture, `${JSON.stringify(after, null, 2)}\n`)
-  const res = run(['--check', '--out', fixture])
-  check(name, res.code === 1 && /stale/.test(res.out), `exit ${res.code}: ${res.out.trim()}`)
-}
-
-if (failures) {
-  console.error(`\ngen-example-sources.negative: ${failures} case(s) did not behave as required.`)
-  process.exit(1)
+import { cachedExample } from './gen-example-sources.mjs'
+
+const scratch = mkdtempSync(join(tmpdir(), 'libtmux-example-cache-'))
+const git = (...args) => execFileSync('git', ['-C', scratch, ...args], { encoding: 'utf8', stdio: 'pipe' }).trim()
+try {
+  git('init', '--quiet')
+  writeFileSync(join(scratch, 'example.go'), '// committed example\n')
+  git('add', 'example.go')
+  git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '--quiet', '-m', 'Example')
+  const revision = git('rev-parse', 'HEAD')
+  const request = { repository: 'fixture/example', revision, file: 'example.go', checkout: scratch }
+  const initial = cachedExample(request)
+  assert.equal(initial.content, '// committed example\n')
+  writeFileSync(join(scratch, 'example.go'), '// uncommitted replacement\n')
+  assert.deepEqual(cachedExample(request), initial)
+  git('add', 'example.go')
+  git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '--quiet', '-m', 'Later revision')
+  assert.deepEqual(cachedExample(request), initial)
+  console.log('ok   examples ignore a dirty working tree and a later HEAD')
+
+  const offline = { ...request, checkout: join(scratch, 'absent'), current: initial }
+  assert.deepEqual(cachedExample(offline), initial)
+  assert.throws(() => cachedExample({ ...offline, current: { ...initial, content: 'damaged' } }), /no verified cache/)
+  assert.throws(() => cachedExample({ ...offline, revision: git('rev-parse', 'HEAD') }), /no verified cache/)
+  assert.throws(() => cachedExample({ ...offline, repository: 'another/repo' }), /no verified cache/)
+  assert.throws(() => cachedExample({ ...offline, current: undefined }), /no verified cache/)
+  assert.throws(() => cachedExample({ ...request, file: 'missing.go' }))
+  console.log('ok   missing files, wrong revisions, wrong repositories and damaged bytes fail')
+} finally {
+  rmSync(scratch, { recursive: true, force: true })
 }
-console.log('gen-example-sources.negative: the staleness check can fail, and passes when current')
diff --git a/scripts/gen-mentions.mjs b/scripts/gen-mentions.mjs
index e7043f09..185af8e9 100755
--- a/scripts/gen-mentions.mjs
+++ b/scripts/gen-mentions.mjs
@@ -14,7 +14,7 @@ const check = process.argv.includes('--check')
 
 const { PORTS: PORT_DEFS } = await import(`file://${resolve(root, 'site/src/lib/ports.ts')}`)
 const PORTS = PORT_DEFS.map((p) => p.slug)
-const { KNOWN_PORTS, resolvePortBody } = await import(`file://${resolve(root, 'site/src/lib/workspace-shared-slots.ts')}`)
+const { KNOWN_PORTS, resolvePortBody, resolvePortContent } = await import(`file://${resolve(root, 'site/src/lib/workspace-shared-slots.ts')}`)
 
 /** The first column's label, as the prose writes it. */
 const PORT_BY_LABEL = {
@@ -159,8 +159,9 @@ for (const { file, source } of [...realEntries, ...sharedWorkspaceEntries(realFi
   if (PORT_DEFS.find((port) => port.slug === authoredPort)?.referenceKind === 'guide') continue
   const product = frontmatterValue(source, 'product') ?? /^ports\/[^/]+\/(workspace|mcp)\//.exec(file)?.[1]
 
-  for (const { port: contextPort, text, line, before, linked } of proseMentions(source, PORT_BY_LABEL)) {
-    const pagePort = contextPort ?? authoredPort
+  const selected = resolvePortContent(source, authoredPort)
+  for (const { port: contextPort, text, line, before, linked } of proseMentions(selected.body, PORT_BY_LABEL, selected.portAt)) {
+    const pagePort = authoredPort ?? contextPort
     if (notASymbol(text)) continue
     const decision = decideMention(text, { pagePort, product, before }, resolver, models)
     if (decision.kind !== 'link') {
diff --git a/scripts/normalize-native-shell.mjs b/scripts/normalize-native-shell.mjs
index 2ec6e2c8..1b28c729 100644
--- a/scripts/normalize-native-shell.mjs
+++ b/scripts/normalize-native-shell.mjs
@@ -1,30 +1,96 @@
 #!/usr/bin/env node
-import { readFileSync, readdirSync, writeFileSync } from 'node:fs'
-import { join, resolve } from 'node:path'
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { dirname, join, relative, resolve, sep } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { Window } from 'happy-dom'
+import { PORT_BY_SLUG } from '../site/src/lib/ports.ts'
 
-/** Keep generated native shell assets inside the assembly's locale and preview. */
-export function normalizeNativeShell(directory, prefix) {
+const currentPage = '__LIBTMUX_NATIVE_CURRENT_PAGE__'
+const escapeAttribute = (text) => text.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;')
+
+/** Render the runtime's own chrome once per port/version, without network access. */
+async function renderChrome(root, port, version) {
+  const window = new Window({ url: `https://libtmux.org${root}/${port.slug}/${version}/api/` })
+  window.fetch = async () => ({ ok: false })
+  try {
+    window.eval(readFileSync(new URL('../site/public/_shell/shell.js', import.meta.url), 'utf8'))
+    window.document.dispatchEvent(new window.Event('DOMContentLoaded'))
+    const header = window.document.querySelector('[data-lt-shell="header"]')
+    const footer = window.document.querySelector('[data-lt-shell="footer"]')
+    const style = window.document.getElementById('lt-shell-style')
+    if (!header || !footer || !style) throw new Error('Native shell did not render its header, footer and styles')
+    for (const link of header.querySelectorAll('[data-page-port-switcher] a[aria-current], a[lang="en"]')) {
+      link.setAttribute('href', currentPage)
+    }
+    return { header: header.outerHTML, footer: footer.outerHTML, style: style.outerHTML }
+  } finally {
+    await window.happyDOM.close()
+  }
+}
+
+/**
+ * Keep generated native shell assets inside the assembly's locale and preview.
+ * @param {string} directory
+ * @param {string} prefix
+ * @param {{ sphinxPort?: string, version?: string }} [options]
+ */
+export async function normalizeNativeShell(directory, prefix, { sphinxPort, version = 'latest' } = {}) {
+  const port = sphinxPort ? PORT_BY_SLUG[sphinxPort] : undefined
+  if (sphinxPort && port?.renderer !== 'sphinx') throw new Error(`Not a Sphinx port: ${sphinxPort}`)
   const root = prefix.replace(/\/+$/, '')
+  const chrome = port ? await renderChrome(root, port, version) : undefined
+  const normalize = (content) => content.replace(/(['"(])(?:https?:\/\/libtmux\.org)?\/_shell\//g, `$1${root}/_shell/`)
+  const adapterPath = join(directory, '_static/libtmux-org.css')
+  if (port) {
+    mkdirSync(dirname(adapterPath), { recursive: true })
+    writeFileSync(adapterPath, normalize(readFileSync(new URL('../site/public/_shell/sphinx.css', import.meta.url), 'utf8')))
+  }
   let changed = 0
-  for (const entry of readdirSync(directory, { withFileTypes: true })) {
-    const path = join(directory, entry.name)
-    if (entry.isDirectory()) {
-      changed += normalizeNativeShell(path, root)
-    } else if (/\.(html|css)$/.test(entry.name)) {
-      const before = readFileSync(path, 'utf8')
-      const after = before.replace(/(['"(])(?:https?:\/\/libtmux\.org)?\/_shell\//g, `$1${root}/_shell/`)
-      if (after !== before) {
-        writeFileSync(path, after)
-        changed++
+  function walk(dir) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const path = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        if (entry.name !== '_sources') walk(path)
+      } else if (/\.(html|css)$/.test(entry.name)) {
+        const before = readFileSync(path, 'utf8')
+        let after = normalize(before)
+        if (port && entry.name.endsWith('.html') && !/<meta\b[^>]*http-equiv=["']refresh["']/i.test(after)) {
+          if (!/<\/head>/i.test(after)) throw new Error(`Native page has no closing head: ${path}`)
+          // Old source refs may predate the shell; replace existing integration once.
+          after = after
+            .replace(/<script\b[^>]*\bsrc=["'][^"']*\/_shell\/shell\.js(?:\?[^"']*)?["'][^>]*>[\s\S]*?<\/script>\s*/gi, '')
+            .replace(/<link\b[^>]*\bhref=["'][^"']*\blibtmux-org\.css(?:\?[^"']*)?["'][^>]*>\s*/gi, '')
+            .replace(/<style\b[^>]*\bid=["']lt-shell-style["'][^>]*>[\s\S]*?<\/style>\s*/gi, '')
+            .replace(/<!-- libtmux-native-(header|footer) -->[\s\S]*?<!-- \/libtmux-native-\1 -->\s*/g, '')
+          const cssUrl = relative(dirname(path), adapterPath).split(sep).join('/')
+          after = after.replace(/<\/head>/i, `<link rel="stylesheet" href="${cssUrl}">\n${chrome.style}\n<script defer src="${root}/_shell/shell.js"></script>\n</head>`)
+          if (!/<body\b[^>]*>/i.test(after) || !/<\/body>/i.test(after)) throw new Error(`Native page has no body: ${path}`)
+          const pageUrl = `${root}/${port.slug}/${version}/api/${relative(directory, path).split(sep).join('/').replace(/index\.html$/, '')}`
+          const header = chrome.header.replaceAll(currentPage, escapeAttribute(pageUrl))
+          after = after
+            .replace(/(<body\b[^>]*>)\s*/i, `$1\n<!-- libtmux-native-header -->${header}<!-- /libtmux-native-header -->\n`)
+            .replace(/\s*<\/body>/i, `\n<!-- libtmux-native-footer -->${chrome.footer}<!-- /libtmux-native-footer -->\n</body>`)
+          if (!/<article\b/i.test(after)) throw new Error(`Native page has no article: ${path}`)
+          after = after.replace(/<article\b([^>]*)>/i, (_tag, attributes) => {
+            const clean = attributes.replace(/\sdata-pagefind-(?:body|filter)(?:=["'][^"']*["'])?/gi, '')
+            return `<article${clean} data-pagefind-body data-pagefind-filter="port:${port.name}">`
+          })
+        }
+        if (after !== before) {
+          writeFileSync(path, after)
+          changed++
+        }
       }
     }
   }
+  walk(directory)
   return changed
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  const [directory, prefix] = process.argv.slice(2)
-  if (!directory || !prefix?.startsWith('/')) throw new Error('Usage: normalize-native-shell.mjs DIRECTORY /LOCALE_PREFIX')
-  console.log(`Native shell URLs: normalized ${normalizeNativeShell(directory, prefix)} HTML/CSS files`)
+  const [directory, prefix, sphinxPort, version] = process.argv.slice(2)
+  if (!directory || !prefix?.startsWith('/')) {
+    throw new Error('Usage: normalize-native-shell.mjs DIRECTORY /LOCALE_PREFIX [SPHINX_PORT VERSION]')
+  }
+  console.log(`Native shell: prepared ${await normalizeNativeShell(directory, prefix, { sphinxPort, version })} HTML/CSS files`)
 }
diff --git a/scripts/stage-port-docs.mjs b/scripts/stage-port-docs.mjs
index fbaefbae..76d29aec 100644
--- a/scripts/stage-port-docs.mjs
+++ b/scripts/stage-port-docs.mjs
@@ -5,6 +5,8 @@ import { execFileSync } from 'node:child_process'
 import { homedir } from 'node:os'
 import { dirname, join, posix, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { fromMarkdown } from 'mdast-util-from-markdown'
+import { toMarkdown } from 'mdast-util-to-markdown'
 import { PORTS } from '../site/src/lib/ports.ts'
 import { sourceGuidesFor, SOURCE_GUIDE_PORTS } from '../site/src/lib/port-documentation.ts'
 
@@ -13,6 +15,7 @@ const output = join(root, 'site/src/content/docs/_staged')
 const selectedPort = process.argv.includes('--port') ? process.argv[process.argv.indexOf('--port') + 1] : undefined
 const check = process.argv.includes('--check')
 const fromSource = process.argv.includes('--from-source')
+const cached = process.argv.includes('--cached')
 const wrappersOnly = process.argv.includes('--wrappers')
 const refreshCache = process.argv.includes('--refresh-cache')
 const cacheRoot = join(root, 'site/src/data/port-guides')
@@ -47,6 +50,14 @@ function external(value) {
 
 export function rewriteLinks(content, sourcePath, route, routes, repo, revision) {
   const targetUrl = (destination, image = false) => {
+    const ownSource = `https://github.com/${repo}/blob/`
+    if (!image && destination.startsWith(ownSource)) {
+      const [ref, ...path] = destination.slice(ownSource.length).split('/')
+      const [target, fragment = ''] = path.join('/').split('#', 2)
+      if (['master', 'main', revision].includes(ref)) {
+        destination = `${posix.relative(posix.dirname(sourcePath), target)}${fragment ? `#${fragment}` : ''}`
+      }
+    }
     if (external(destination)) return destination
     const [target, fragment = ''] = destination.split('#', 2)
     const normalized = posix.normalize(posix.join(posix.dirname(sourcePath), target))
@@ -58,11 +69,21 @@ export function rewriteLinks(content, sourcePath, route, routes, repo, revision)
     }
     return `https://github.com/${repo}/${image ? 'raw' : 'blob'}/${revision}/${normalized}${fragment ? `#${fragment}` : ''}`
   }
+  // Scala calls such as resource[IO](config) look like Markdown links.
+  // Parse first so code remains byte-for-byte source-owned, then replace
+  // only real links; the rest of the guide keeps its authored formatting.
+  const editsFor = (node) => {
+    const children = (node.children ?? []).flatMap(editsFor)
+    if (!['link', 'image', 'definition'].includes(node.type)) return children
+    const url = targetUrl(node.url, node.type === 'image')
+    if (url === node.url) return children
+    node.url = url
+    return [{ start: node.position.start.offset, end: node.position.end.offset,
+      text: toMarkdown(node).trimEnd() }]
+  }
+  const edits = editsFor(fromMarkdown(content)).sort((a, b) => b.start - a.start)
+  for (const { start, end, text } of edits) content = content.slice(0, start) + text + content.slice(end)
   return content
-    .replace(/(!?)\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g,
-      (_all, image, label, destination) => `${image}[${label}](${targetUrl(destination, Boolean(image))})`)
-    .replace(/^(\[[^\]]+\]:)\s*\n?\s*(\S+)/gm,
-      (_all, label, destination) => `${label} ${targetUrl(destination)}`)
 }
 
 export function stagedPortGuides(port, artifact) {
@@ -92,20 +113,23 @@ export function stagedPortGuides(port, artifact) {
     files.set(`${port}/${route}/index.md`, `---\n${frontmatter}\n---\n\n${rewritten.trim()}\n`)
   }
   const identity = PORTS.find((entry) => entry.slug === port)
-  if (identity.parentLibrary) {
+  {
     const source = { repo: artifact.source.repository, path: Object.keys(routes)[0], ref: artifact.source.revision }
     const writeIndex = (route, title, body, cards = []) => {
       const data = { title, description: `${title} for ${identity.packageName}.`, port, route, source, cards,
-        sidebar: { group: route === 'reference' ? 'API reference' : 'Guides', order: 0 } }
+        sidebar: { group: route === 'reference' ? 'API reference' : route[0].toUpperCase() + route.slice(1), order: 0 } }
       const frontmatter = Object.entries(data).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join('\n')
       files.set(`${port}/${route}/index.md`, `---\n${frontmatter}\n---\n\n${body}\n`)
     }
-    const cards = Object.entries(routes).filter(([, entry]) => entry.route.startsWith('guides/'))
-      .map(([path, entry]) => ({ label: titleAndBody(guides.get(path), path).title,
-        href: `./${entry.route.slice('guides/'.length)}/`, body: `Read the ${identity.name} package guide.` }))
-    writeIndex('guides', `${identity.name} guides`,
-      `These guides come from the ${identity.packageName} sources at this documentation revision.`, cards)
-    if (identity.ecosystemHost) writeIndex('reference', `${identity.name} API reference`,
+    for (const section of identity.parentLibrary ? ['guides'] : ['guides', 'examples', 'topics']) {
+      const ownSection = Object.entries(routes).filter(([, entry]) => entry.route.startsWith(`${section}/`))
+      const selected = ownSection.length ? ownSection : Object.entries(routes).filter(([, entry]) => entry.domain === 'core' && entry.route.startsWith('guides/'))
+      const cards = selected.map(([path, entry]) => ({ label: titleAndBody(guides.get(path), path).title,
+        href: `../${entry.route}/`, body: `Read the ${identity.name} guide and its examples.` }))
+      writeIndex(section, `${identity.name} ${section}`,
+        `Use these ${identity.packageName} guides for the APIs and examples in this version.`, cards)
+    }
+    if (identity.parentLibrary && identity.ecosystemHost) writeIndex('reference', `${identity.name} API reference`,
       `Use the [${identity.ecosystemHost.name} reference](${identity.ecosystemHost.url}) for published package versions.\n\nThe [source at this documentation revision](https://github.com/${source.repo}/tree/${source.ref}/${posix.dirname(source.path)}/src/main) contains the wrapper declarations and their documentation.\n\n${identity.name} and its ${identity.parentLibrary.runtime} core share a release version.`)
   }
   return files
@@ -114,43 +138,49 @@ export function stagedPortGuides(port, artifact) {
 function artifactFromSource(port, checkout) {
   const modelPath = join(root, `site/src/data/api/${port.slug}.json`)
   const model = port.parentLibrary ? undefined : JSON.parse(readFileSync(modelPath, 'utf8'))
-  const head = execFileSync('git', ['-C', checkout, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim()
-  if (model && head !== model.revision) {
-    throw new Error(`${port.slug}: checkout ${head} differs from integrated model ${model.revision}`)
-  }
+  const revision = model?.revision ?? execFileSync('git', ['-C', checkout, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim()
   return {
-    source: { repository: port.repo, revision: head },
+    source: { repository: port.repo, revision },
     guides: Object.keys(ROUTES[port.slug]).map((path) => ({
       path,
-      content: readFileSync(join(checkout, path), 'utf8'),
+      content: execFileSync('git', ['-C', checkout, 'show', `${revision}:${path}`], { encoding: 'utf8', maxBuffer: 4 * 1024 * 1024 }),
     })),
   }
 }
 
 export function run() {
   if (selectedPort && !(selectedPort in ROUTES)) throw new Error(`unsupported staged port: ${selectedPort}`)
+  const publicationPort = process.env.LIBTMUX_DOCS_SOURCE_SHA && process.env.LIBTMUX_DOCS_PORT
+  if (cached && selectedPort && selectedPort === publicationPort) {
+    throw new Error(`--cached cannot stage selected publication port ${selectedPort}; regenerate its source guides first`)
+  }
   const generated = new Map()
-  const selected = PORTS.filter((entry) => entry.slug in ROUTES && (!selectedPort || entry.slug === selectedPort) && (!wrappersOnly || entry.parentLibrary))
-  if (refreshCache && (!selectedPort || !selected[0]?.parentLibrary)) throw new Error('--refresh-cache requires one wrapper --port')
+  const selected = PORTS.filter((entry) => entry.slug in ROUTES && (!selectedPort || entry.slug === selectedPort)
+    && (!wrappersOnly || entry.parentLibrary) && !(cached && entry.slug === publicationPort))
+  if (refreshCache && !selectedPort) throw new Error('--refresh-cache requires one --port')
   for (const port of selected) {
     const checkout = expand(process.env[`LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`] || port.worktree)
     const artifactPath = join(checkout, 'docs/_build/api.json')
     const selectedSource = process.env.LIBTMUX_DOCS_PORT === port.slug && process.env.LIBTMUX_DOCS_SOURCE_SHA
     const cachePath = join(cacheRoot, `${port.slug}.json`)
     const liveWrapper = port.parentLibrary && (refreshCache || selectedSource || (selectedPort && fromSource))
-    if (!port.parentLibrary && !fromSource && !existsSync(artifactPath)) throw new Error(`${port.slug}: native artifact missing at ${artifactPath}`)
-    const artifact = port.parentLibrary && !liveWrapper
+    if (!cached && !port.parentLibrary && !fromSource && !existsSync(artifactPath)) throw new Error(`${port.slug}: native artifact missing at ${artifactPath}`)
+    const artifact = cached || (port.parentLibrary && !liveWrapper)
       ? JSON.parse(readFileSync(cachePath, 'utf8'))
       : fromSource || liveWrapper ? artifactFromSource(port, checkout)
       : JSON.parse(readFileSync(artifactPath, 'utf8'))
     if (artifact.source.repository !== port.repo || !/^[a-f0-9]{40}$/.test(artifact.source.revision)) {
       throw new Error(`${port.slug}: invalid source guide provenance`)
     }
+    if (!port.parentLibrary) {
+      const model = JSON.parse(readFileSync(join(root, `site/src/data/api/${port.slug}.json`), 'utf8'))
+      if (artifact.source.revision !== model.revision) throw new Error(`${port.slug}: guide source ${artifact.source.revision} differs from integrated model ${model.revision}`)
+    }
     const expected = selectedSource
     if (expected && artifact.source?.revision !== expected) {
       throw new Error(`${port.slug}: expected source ${expected}, artifact records ${artifact.source?.revision}`)
     }
-    if (port.parentLibrary && !check && (refreshCache || selectedSource)) {
+    if (!check && (refreshCache || selectedSource)) {
       mkdirSync(cacheRoot, { recursive: true })
       writeFileSync(cachePath, `${JSON.stringify(artifact, null, 2)}\n`)
     }
diff --git a/scripts/test-loop.mjs b/scripts/test-loop.mjs
index 9c47a6b1..389d9581 100644
--- a/scripts/test-loop.mjs
+++ b/scripts/test-loop.mjs
@@ -69,11 +69,13 @@ try {
   if (loop !== 'inner') checks.push(
     pnpm('run', '--recursive', 'lint'),
     pnpm('exec', 'oxlint', 'scripts'),
+    node('scripts/check-api-links.mjs'),
     node('scripts/gen-mentions.mjs', '--check'),
     node('scripts/gen-shell-ports.mjs', '--check'),
     node('scripts/gen-brand-css.mjs', '--check'),
   )
   if (loop === 'outer') checks.push(
+    node('scripts/gen-example-sources.mjs', '--check'),
     pnpm('run', '--recursive', 'type-check'),
     node('site/scripts/check-dev.mjs'),
   )
diff --git a/site/public/_shell/README.md b/site/public/_shell/README.md
index dd9d87ba..9705be82 100644
--- a/site/public/_shell/README.md
+++ b/site/public/_shell/README.md
@@ -1,219 +1,66 @@
-# `/_shell/` — the design-token bridge
+# Native reference navigation and theme
 
-This file lives under `site/public/`, so Astro publishes it verbatim to
-`libtmux.org/_shell/README.md` on every build — the same passthrough that
-publishes `tokens.css` and `shell.js` from this directory. It is not
-gated behind anything private; the `~/work/...` paths and the
-`build-site.sh` bug narrative below are written the way they are (no
-absolute machine paths, no assumptions about who is reading) because this
-is effectively a public document already.
+The shared assets give native reference pages the site's navigation, version
+switcher, API equivalents, and theme. Assets live under the locale's `_shell/`
+directory, including the preview prefix when present.
 
-Closes the largest open item in `notes/status.md`: Python and C++ rendered
-as stock Furo — their own title, their own header, no port switcher, no
-version switcher, none of the site's palette. A reader moving from `/ts/`
-to `/py/` landed on what looked like a different website. Full design in
-`notes/research/03-design-token-bridge.md`.
+| File | Purpose |
+| --- | --- |
+| `shell.js` | Header, footer, port and version switching, and theme synchronization. |
+| `tokens.css` | Shared light and dark theme values. |
+| `sphinx.css` | Maps shared tokens to Furo's CSS variables. |
+| `brand.css` | Port colors and artwork used by native pages. |
 
-## The three artifacts
+## Sphinx integration
 
-| File | What it is | Who loads it |
-|---|---|---|
-| `tokens.css` | ~25 semantic `--lt-*` custom properties (light default, `[data-theme="dark"]` override, `prefers-color-scheme` fallback) | Never linked directly by a foreign generator — pulled in transitively via each generator's own adapter stylesheet's `@import` |
-| `shell.js` | Header/footer injection, the version switcher, and a dark-mode shim | Loaded directly via each generator's script-injection flag (Sphinx: `html_js_files`) |
-| `README.md` | This file | Nobody; documentation only |
+After Sphinx builds the selected source revision, `scripts/build-site.sh`
+runs `scripts/normalize-native-shell.mjs`. It copies `sphinx.css` to the
+reference's `_static/libtmux-org.css`, then adds its stylesheet and the shared
+script to each page. It renders the script's own header, footer and styles once
+per port/version, using Happy DOM without network access. The header is present
+at first paint, so loading the script does not push the article down.
+Existing integration is replaced once; redirects retain
+their original behavior. This step does not edit source checkouts or their
+Sphinx configuration.
 
-Both are served from a **stable, unversioned URL**
-(`https://libtmux.org/_shell/tokens.css`, `.../shell.js`) — not copied into
-each build. That is deliberate: a chrome-color fix or a header bug fix
-reaches every already-published, immutable version prefix (`/py/v0.46.2/`,
-`/cxx/v1.2.0/`, …) without rebuilding that version. See
-`notes/research/00-DECISIONS.md` §6 ("load the shared header, footer,
-version switcher and tokens at runtime from a stable URL").
+The stylesheet loads after the native theme and imports the locale's
+`_shell/tokens.css`. Its fallbacks retain Furo colors if shared tokens cannot
+load. Other native asset URLs are normalized to the same locale and preview.
 
-Two research documents (`03-design-token-bridge.md`,
-`14-lang-rust.md`, `07-ci-topology.md`) describe this prefix as
-**versioned**, `/_shell/v1/`, for exactly this reason — a breaking change
-bumps to `/_shell/v2/` instead of breaking every generator that already
-baked in the v1 URL. A third (`16-lang-java-kotlin.md`) and this
-assignment's own file list use the **unversioned** `/_shell/` path. This
-implementation follows the assignment's literal paths
-(`site/public/_shell/{tokens,shell}.{css,js}`). Flagged as an open
-contradiction between research documents; adding a `v1/` segment later is a
-rename of these two files plus every conf.py that references them, not a
-redesign.
+This allows older library revisions to receive the current site navigation
+without requiring shell integration in their own source tree. A standalone
+Sphinx build remains controlled by its repository's configuration.
 
-## Why the Astro shell itself does not consume these
+## Runtime contracts
 
-The Astro shell (`site/src/styles/global.css`) has its own, richer,
-multi-theme token system (`emerald`/`amber`/`sky`/`purple` palettes via
-`html[data-theme]`, light/dark via `html[data-theme-mode]`). `tokens.css`
-is deliberately the narrow, lowest-common-denominator subset a *foreign*
-generator's own CSS can plausibly repaint with — Furo has no slot for four
-selectable brand hues, only one accent. The two systems name their
-attributes the same way for unrelated things (`html[data-theme]` means
-"which brand palette" in the shell, "resolved light/dark" for this
-bridge) — this only matters if a future shell page ever loads `tokens.css`
-directly, which none does today. Flagged as an open naming collision
-rather than resolved, since resolving it means picking a side without a
-second consumer to test against.
+`shell.js` reads `versions.json` and `page-links.json` from the locale root.
+The generated port table comes from `site/src/lib/ports.ts`; regenerate it
+with `node scripts/gen-shell-ports.mjs` after changing port identities.
 
-## The adapter problem
+Native pages read Astro's `color-scheme` preference first, translating
+`system` to Furo's `auto`. Native toggles update that key, Furo's `theme`,
+and the legacy `libtmux-theme` key. Test navigation in both directions when
+changing this contract.
 
-`tokens.css` restyles nothing by itself. Each foreign generator paints
-from its own variable system, so each needs a small **adapter
-stylesheet** — a translation table from the ~25 `--lt-*` names onto that
-generator's real variables, loaded through that generator's own override
-mechanism. Today that is Furo, for the two Sphinx-rendered ports:
+The script and tokens use stable URLs so navigation and theme fixes can reach
+previously published references. Changes must preserve existing page contracts.
+The script enhances existing navigation without replacing it, and still inserts
+navigation on older pages that have no initial header.
 
-- `~/work/python/libtmux-python-docs/docs/_static/libtmux-org.css` (Python
-  — `sphinx-gp-theme`, a Furo child theme)
-- `~/work/libtmux/libtmux-cxx-docs/docs/_static/libtmux-org.css` (C++ —
-  vanilla Furo via Doxygen → Breathe)
+## Verification
 
-Both map the same ~25 names onto the same Furo `--color-*` contract
-(harvested from upstream Furo's SCSS at
-`~/work/python/gp-sphinx/packages/gp-furo-tokens/src/{light,dark}.ts` —
-verified against the actual built output at
-`_site/py/*/api/_static/styles/furo-tw.css` and
-`_site/cxx/*/api/_static/styles/furo.css` before writing the mapping, not
-assumed). The two files are near-identical and kept in sync by hand —
-there is no shared npm package either Sphinx build could import from
-(`gp-furo-tokens` is `"private": true`); this is the one duplication cost
-the design accepts, and it is the *mapping* that is duplicated (~60 lines),
-not the token *values* (which stay centralized in `tokens.css` via
-`@import` — see "Rejected: vendoring" in
-`notes/research/03-design-token-bridge.md` §1).
-
-Every mapping in the adapter carries Furo's own stock color as a `var()`
-fallback (`--color-brand-primary: var(--lt-color-accent, #0a4bff)`). This
-is load-bearing: the site has never been deployed (`notes/status.md`), so
-every page loads `tokens.css` cross-origin from wherever it is actually
-served today — a fetch that 404s until DNS resolves. Per the CSS custom
-properties spec, `var()` on an undefined property with no fallback
-resolves to the guaranteed-invalid value, which would make every rule
-reading `--color-background-primary` compute to nothing — transparent
-backgrounds, UA-default text — strictly worse than the stock-Furo glitch
-this closes. The fallback is Furo's own value, not a libtmux one, so
-degrading means "looks like unmodified Furo," not "looks half-skinned."
-
-Each conf.py wires the adapter in with two config values:
-
-```python
-html_static_path = ["_static"]  # cxx only — Python's already has this
-html_css_files = ["libtmux-org.css"]  # appended after any project CSS
-html_js_files = [("https://libtmux.org/_shell/shell.js", {"defer": "defer"})]
-```
-
-`html_css_files`/`html_js_files` accept a full external URL verbatim
-(Sphinx's own `add_css_file`/`add_js_file`: a filename containing `://` is
-never rewritten to `_static/…`) — confirmed against the installed Sphinx
-source, not assumed from documentation. `libtmux-org.css` must be **last**
-in the list: Sphinx emits `html_css_files` after every extension's own
-bundled CSS (including Furo's), so appending guarantees the adapter's
-`body { --color-x: var(--lt-y) }` overrides land after Furo's own
-`--color-x` declaration at equal specificity and wins.
-
-## The version switcher contract
-
-`shell.js`'s `<libtmux-version-switcher>` custom element is a hand-kept
-port of `site/src/components/VersionSwitcher.astro`'s inline script —
-same element name, same `data-port`/`data-current` dataset keys, same
-`/versions.json` fetch and schema check, same supported-only filtering,
-same eol-suffix labelling, same path-preserving navigation on change, and
-the same ecosystem-port suppression (a port whose `referenceMode` is
-`'ecosystem'` never gets a switcher — its versions live on docs.rs /
-pkg.go.dev / javadoc.io, which have their own). If
-`VersionSwitcher.astro`'s contract changes, `shell.js` must change with
-it; nothing enforces that automatically.
-
-`shell.js` also carries a small, hand-kept-in-sync copy of the fields it
-needs from `site/src/lib/ports.ts` (slug, display name, `referenceMode`,
-and — for ecosystem ports — the exact `ecosystemHost.url`, copied
-verbatim). A runtime script has no bundler and cannot import that module;
-`ThemeScript.astro` already accepts the identical trade-off for
-`theme-config.ts`, with the same comment shape, for the same reason.
-
-## The dark-mode shim
-
-"Shim, don't replace" (`03-design-token-bridge.md` §4): Furo keeps its own
-toggle button, its own `theme` `localStorage` key, and its own
-`body[data-theme]` attribute. `shell.js` never touches Furo's click
-handler — it observes the resulting `body[data-theme]` mutation (via
-`MutationObserver`, since Furo's toggle fires no event of its own) and
-mirrors the *resolved* light/dark value onto `html[data-theme]`, which is
-the attribute `tokens.css` actually reads. A page can legitimately show
-two theme controls (Furo's native one, plus whatever the injected header
-grows later) — both read the same synced state, so they cannot disagree,
-which is the seam `03-design-token-bridge.md` §4 explicitly accepts rather
-than papering over with a fork of Furo's toggle.
-
-`notes/research/00-DECISIONS.md` §7.13 leaves the canonical cross-site
-`localStorage` key an open decision ("pick one before `shell.js` ships").
-This implementation picks `libtmux-theme` and records that choice in
-`shell.js`'s own comments rather than in a separate document. It has not
-been reconciled with `social-embed`'s `starlight-theme` key — that
-remains open, and only matters if `libtmux.org` and `social-embed.org`
-(or another `git-pull.com` property) are ever meant to share a dark-mode
-preference across visits.
-
-One accepted flash: Furo's inline pre-paint script sets
-`body[data-theme]` synchronously, before `shell.js` (deferred) runs. If
-the reader's explicit preference disagrees with the OS (e.g. chose "dark"
-while the OS is light), `tokens.css`'s `prefers-color-scheme` fallback
-briefly disagrees with Furo's own paint until `shell.js` sets
-`html[data-theme]` explicitly. The "auto" case has no flash at all, since
-`tokens.css`'s media-query block matches with no attribute present. This
-is the same one-frame trade-off `03-design-token-bridge.md` §4 names
-explicitly rather than rewriting Furo's boot script to defer to ours.
-
-A sibling case is not just a flash: if `shell.js` itself fails to load
-(same-origin as `tokens.css`, so this fails together with it, but keep the
-two failure modes distinct) while the reader's explicit preference is
-"dark" and the OS is light, `html[data-theme]` is simply never written —
-Furo still paints dark correctly from its own `body[data-theme]`, but
-`tokens.css`'s fallback block (`prefers-color-scheme: dark`) never
-matches, so **every `--lt-*` token stays at its light value for the
-session**, not just for one frame. The adapter's own `var(--lt-x,
-<furo-stock-light>)` fallback then supplies the *light* stock color inside
-a page Furo has painted dark — a legible but visibly wrong combination,
-not a broken one. This is the direct consequence of `shell.js` being the
-only thing that writes `html[data-theme]`; there is no second mechanism to
-fall back to.
-
-## Verifying it actually happened
-
-`scripts/inject-shell.mjs` is the post-build smoke test: it reads
-`site/src/lib/ports.ts` for the self-hosted Sphinx ports, walks every
-built `<port>/<version>/api/` page, and asserts the adapter link and
-`shell.js` script tag are present, the adapter still `@import`s
-`tokens.css` from the real URL, every `--color-*` name the adapter writes
-still exists in that build's own generated CSS (catches a Furo upgrade
-silently renaming or dropping one), and every `--lt-*` name the adapter
-reads exists in `tokens.css` (catches a typo on our side). Run it after
-`scripts/build-site.sh`:
+After assembling the site, run:
 
 ```console
-$ node scripts/inject-shell.mjs
+$ node scripts/inject-shell.mjs --site _site
 ```
 
-A port with nothing built yet is reported as skipped, not failed. Any
-other failure exits non-zero.
-
-This script proves the wiring is present and internally consistent — the
-right tags exist, the right variable names exist on both sides of the
-mapping. It does not prove the injected header/footer actually look right
-next to Furo's own flex/sticky layout in a real browser; that visual QA
-has not been done and is unverified.
+The check inspects every built Sphinx page for the script and stylesheet,
+checks locale URLs, and compares the adapter's variables with the generated
+theme and shared tokens. Missing references are reported as skips. Broken
+integration fails the command.
 
-**Known failure as of this writing**: running the check above reports
-`py/stable` as failing every check, while `cxx/stable` passes. This is not
-a bug in the adapter or in `shell.js` — direct `sphinx-build` runs against
-`~/work/python/libtmux-python-docs/docs` (this file's own conf.py) produce
-the correct `<head>` tags every time. The cause is in
-`scripts/build-site.sh`'s `build_reference()`: it redirects `cxx` and
-`dotnet` to their `docs-site` worktree when that worktree carries the
-generator's entrypoint, but the equivalent `py)` case is missing from that
-same `case` statement, so the Python build actually runs against
-`~/work/python/libtmux/docs/conf.py` (the main checkout) instead of the
-worktree this fix lives in. `build-site.sh` is not owned by this piece of
-work; see the top-level summary for this contradiction reported upstream.
+The output tests cover native asset paths; `normalize-native-shell.test.ts`
+covers older sources, existing integration, previews, redirects, repeated
+assembly, and malformed HTML. Use a browser to verify switching, themes, and
+layout on the assembled native pages.
diff --git a/site/public/_shell/shell.js b/site/public/_shell/shell.js
index 3023ba13..58115b54 100644
--- a/site/public/_shell/shell.js
+++ b/site/public/_shell/shell.js
@@ -206,7 +206,9 @@
     ;[['Reference', '/reference/'], ['MCP', '/mcp/'], ['Search', '/search/']].forEach(function (entry) {
       var link = document.createElement('a')
       link.className = 'lt-shell-search-link'
-      link.href = siteRoot + entry[1]
+      link.href = entry[0] === 'Search' && currentPort && currentVersion
+        ? siteRoot + '/' + currentPort + '/' + currentVersion + entry[1]
+        : siteRoot + entry[1]
       link.textContent = entry[0]
       controls.appendChild(link)
     })
@@ -244,11 +246,13 @@
     '.lt-shell-header,.lt-shell-footer{font-family:var(--lt-font-sans,sans-serif);' +
     'font-size:0.875rem;background:var(--lt-color-bg,#fff);color:var(--lt-color-fg,#000);box-sizing:border-box}' +
     '.lt-shell-header *,.lt-shell-footer *{box-sizing:border-box}' +
-    '.lt-shell-header{display:flex;flex-wrap:wrap;align-items:center;gap:0.75rem;' +
+    // Furo's fixed table of contents uses layer 50.
+    '.lt-shell-header{position:relative;z-index:51;display:flex;flex-wrap:wrap;align-items:center;gap:0.75rem;' +
     'padding:0.6rem 1rem;border-bottom:1px solid var(--lt-color-border,#eeebee)}' +
     '.lt-shell-brand{font-family:var(--lt-font-mono,monospace);font-weight:600;' +
     'font-size:1.05rem;color:var(--lt-color-fg,#000);text-decoration:none;letter-spacing:-0.01em}' +
-    '.lt-shell-nav{display:flex;flex-wrap:wrap;gap:0.15rem;flex:1}' +
+    // Wrap the controls before the language list can collapse into a column.
+    '.lt-shell-nav{display:flex;flex-wrap:wrap;gap:0.15rem;flex:1 1 15rem}' +
     '.lt-shell-nav-link{padding:0.25rem 0.5rem;border-radius:var(--lt-radius,0.375rem);' +
     'color:var(--lt-color-fg-secondary,#5a5c63);text-decoration:none}' +
     '.lt-shell-nav-link:hover{background:var(--lt-color-bg-hover,#efeff4)}' +
@@ -277,14 +281,19 @@
     '.lt-shell-footer-list a:hover{text-decoration:underline}'
 
   function injectChrome() {
-    if (document.getElementById('lt-shell-style')) return
-    var style = document.createElement('style')
-    style.id = 'lt-shell-style'
-    style.textContent = CHROME_STYLE
-    document.head.appendChild(style)
+    if (!document.getElementById('lt-shell-style')) {
+      var style = document.createElement('style')
+      style.id = 'lt-shell-style'
+      style.textContent = CHROME_STYLE
+      document.head.appendChild(style)
+    }
     defineVersionSwitcher()
-    document.body.insertBefore(buildHeader(), document.body.firstChild)
-    document.body.appendChild(buildFooter())
+    // Current native builds include chrome in the first paint. Keep the
+    // insertion fallback for references published before that integration.
+    if (!document.querySelector('[data-lt-shell="header"]')) {
+      document.body.insertBefore(buildHeader(), document.body.firstChild)
+    }
+    if (!document.querySelector('[data-lt-shell="footer"]')) document.body.appendChild(buildFooter())
     refreshPagePorts()
     manifest.then(function (data) {
       if (!data || data.schema !== 1) return
@@ -306,76 +315,68 @@
     window.addEventListener('hashchange', refreshPagePorts)
   }
 
-  // ---------------------------------------------------------------------
-  // Dark-mode shim (design-token-bridge.md §4: shim, don't replace).
-  //
-  // Canonical key: `libtmux-theme`. notes/research/00-DECISIONS.md §7.13
-  // leaves this an open decision ("pick one before shell.js ships"); this
-  // file makes the call and records it here rather than in a separate
-  // document. Furo's own key (`theme`) stays authoritative for Furo's own
-  // toggle and paint logic — this shim only mirrors the *resolved* value
-  // onto html[data-theme], which is the attribute tokens.css reads, and
-  // writes the canonical key through so a future non-Furo generator (or
-  // the Astro shell, if it ever adopts this key — see the open question in
-  // the same section) can agree on "what did the reader last choose"
-  // without re-deriving it from Furo's storage format.
-  // ---------------------------------------------------------------------
-  var CANONICAL_KEY = 'libtmux-theme'
-  var FURO_KEY = 'theme' // gp-furo-theme's furo.ts: localStorage.setItem('theme', mode)
+  // Astro stores `system`; Furo stores the same preference as `auto`.
+  var SITE_THEME_KEY = 'color-scheme'
+  var LEGACY_THEME_KEY = 'libtmux-theme'
+  var FURO_KEY = 'theme'
+  var themePreference
 
   function systemPrefersDark() {
     return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches
   }
 
+  function nativePreference(value) {
+    if (value === 'system') return 'auto'
+    return value === 'light' || value === 'dark' || value === 'auto' ? value : null
+  }
+
   function readPreference() {
-    // Furo's own key is authoritative for what actually painted this page
-    // (its inline pre-paint script already ran); fall back to the
-    // canonical key, then "auto".
     try {
-      var native = localStorage.getItem(FURO_KEY)
-      if (native === 'light' || native === 'dark' || native === 'auto') return native
+      var stored = nativePreference(localStorage.getItem(SITE_THEME_KEY)) ||
+        nativePreference(localStorage.getItem(FURO_KEY)) ||
+        nativePreference(localStorage.getItem(LEGACY_THEME_KEY))
+      if (stored) return stored
     } catch (e) {
       /* storage disabled */
     }
+    return themePreference || nativePreference(document.body && document.body.getAttribute('data-theme')) || 'auto'
+  }
+
+  function storePreference(key, value) {
     try {
-      var canonical = localStorage.getItem(CANONICAL_KEY)
-      if (canonical === 'light' || canonical === 'dark' || canonical === 'auto') return canonical
+      // Avoid storage-event loops between pages mirroring the same choice.
+      if (localStorage.getItem(key) !== value) localStorage.setItem(key, value)
     } catch (e) {
-      /* storage disabled */
+      /* The current page still follows the native toggle. */
     }
-    return 'auto'
   }
 
-  function applyResolvedTheme() {
-    var pref = readPreference()
-    var resolved = pref === 'auto' ? (systemPrefersDark() ? 'dark' : 'light') : pref
+  function applyResolvedTheme(pref) {
+    themePreference = pref || readPreference()
+    var resolved = themePreference === 'auto' ? (systemPrefersDark() ? 'dark' : 'light') : themePreference
+    var sitePreference = themePreference === 'auto' ? 'system' : themePreference
+    var root = document.documentElement
+    root.setAttribute('data-color-scheme', sitePreference)
+    root.setAttribute('data-theme-mode', resolved)
+    root.style.colorScheme = resolved
+    if (themePreference === 'auto') root.removeAttribute('data-theme')
+    else root.setAttribute('data-theme', resolved)
 
-    // html[data-theme] is what tokens.css keys off. "auto" is never
-    // written here — the fallback in tokens.css already tracks the media
-    // query on its own, so an explicit attribute would only fight it on
-    // the next OS-level change.
-    if (pref === 'auto') {
-      document.documentElement.removeAttribute('data-theme')
-    } else {
-      document.documentElement.setAttribute('data-theme', resolved)
-    }
-
-    // Write through the canonical key so it never drifts from what Furo's
-    // own toggle just decided.
-    try {
-      localStorage.setItem(CANONICAL_KEY, pref)
-    } catch (e) {
-      /* storage disabled */
+    // Furo paints and cycles from its own body attribute and storage key.
+    if (document.body && document.body.getAttribute('data-theme') !== themePreference) {
+      document.body.setAttribute('data-theme', themePreference)
     }
+    storePreference(SITE_THEME_KEY, sitePreference)
+    storePreference(FURO_KEY, themePreference)
+    storePreference(LEGACY_THEME_KEY, themePreference)
   }
 
   function watchNativeToggle() {
-    // Furo's toggle button mutates document.body's data-theme attribute
-    // directly with no event of its own — observe that instead of
-    // reimplementing its click handler, which is the fork this bridge is
-    // built to avoid (design-token-bridge.md §4).
     if (!window.MutationObserver || !document.body) return
-    new MutationObserver(applyResolvedTheme).observe(document.body, {
+    new MutationObserver(function () {
+      var pref = nativePreference(document.body.getAttribute('data-theme'))
+      if (pref && pref !== themePreference) applyResolvedTheme(pref)
+    }).observe(document.body, {
       attributes: true,
       attributeFilter: ['data-theme'],
     })
@@ -384,13 +385,15 @@
   function watchSystemPreference() {
     if (!window.matchMedia) return
     window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', function () {
-      if (readPreference() === 'auto') applyResolvedTheme()
+      if (themePreference === 'auto') applyResolvedTheme('auto')
     })
   }
 
   function watchCrossTab() {
     window.addEventListener('storage', function (e) {
-      if (e.key === FURO_KEY || e.key === CANONICAL_KEY) applyResolvedTheme()
+      if (e.key === SITE_THEME_KEY || e.key === FURO_KEY || e.key === LEGACY_THEME_KEY || e.key === null) {
+        applyResolvedTheme()
+      }
     })
   }
 
diff --git a/site/public/_shell/sphinx.css b/site/public/_shell/sphinx.css
new file mode 100644
index 00000000..f98c86cc
--- /dev/null
+++ b/site/public/_shell/sphinx.css
@@ -0,0 +1,96 @@
+/* Map shared site tokens to Furo, after the generated theme stylesheet. */
+@import url('/_shell/tokens.css');
+
+body {
+  --color-background-primary: var(--lt-color-bg, white);
+  --color-background-secondary: var(--lt-color-bg-secondary, #f8f9fb);
+  --color-background-hover: var(--lt-color-bg-hover, #efeff4);
+
+  --color-foreground-primary: var(--lt-color-fg, black);
+  --color-foreground-secondary: var(--lt-color-fg-secondary, #5a5c63);
+  --color-foreground-muted: var(--lt-color-fg-muted, #6b6f76);
+
+  --color-background-border: var(--lt-color-border, #eeebee);
+
+  --color-brand-primary: var(--lt-color-accent, #0a4bff);
+  --color-brand-content: var(--lt-color-link, #2757dd);
+  --color-brand-visited: var(--lt-color-link-visited, #872ee0);
+
+  --color-inline-code-background: var(--lt-color-code-bg, #f8f9fb);
+  --color-highlighted-background: var(--lt-color-highlighted-bg, #ddeeff);
+
+  --color-api-added: var(--lt-color-added, #21632c);
+  --color-api-removed: var(--lt-color-removed, #b30000);
+  --color-api-changed: var(--lt-color-changed, #046172);
+  --color-api-deprecated: var(--lt-color-deprecated, #605706);
+
+  /* Keep Furo fallbacks when shared tokens are unavailable. */
+  --color-admonition-title--danger: var(--lt-color-danger, #ff5252);
+  --color-admonition-title--error: var(--lt-color-danger, #ff5252);
+  --color-admonition-title--attention: var(--lt-color-danger, #ff5252);
+  --color-admonition-title--warning: var(--lt-color-warning, #ff9100);
+  --color-admonition-title--caution: var(--lt-color-warning, #ff9100);
+  --color-admonition-title--note: var(--lt-color-info, #00b0ff);
+  --color-admonition-title--seealso: var(--lt-color-info, #448aff);
+  --color-admonition-title--hint: var(--lt-color-success, #00c852);
+  --color-admonition-title--tip: var(--lt-color-success, #00c852);
+
+  --font-stack:
+    var(--lt-font-sans, -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial,
+      sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji');
+  --font-stack--monospace:
+    var(--lt-font-mono, 'SFMono-Regular', Menlo, Consolas, Monaco, 'Liberation Mono',
+      'Lucida Console', monospace);
+}
+
+@media not print {
+  body[data-theme='dark'] {
+    --color-background-primary: var(--lt-color-bg, #131416);
+    --color-background-secondary: var(--lt-color-bg-secondary, #1a1c1e);
+    --color-background-hover: var(--lt-color-bg-hover, #1e2124);
+
+    --color-foreground-primary: var(--lt-color-fg, #cfd0d0);
+    --color-foreground-secondary: var(--lt-color-fg-secondary, #9ca0a5);
+    --color-foreground-muted: var(--lt-color-fg-muted, #81868d);
+
+    --color-background-border: var(--lt-color-border, #303335);
+
+    --color-brand-primary: var(--lt-color-accent, #3d94ff);
+    --color-brand-content: var(--lt-color-link, #5ca5ff);
+    --color-brand-visited: var(--lt-color-link-visited, #b27aeb);
+
+    --color-inline-code-background: var(--lt-color-code-bg, #1a1c1e);
+    --color-highlighted-background: var(--lt-color-highlighted-bg, #083563);
+
+    --color-api-added: var(--lt-color-added, #3db854);
+    --color-api-removed: var(--lt-color-removed, #ff7575);
+    --color-api-changed: var(--lt-color-changed, #09b0ce);
+    --color-api-deprecated: var(--lt-color-deprecated, #b1a10b);
+  }
+
+  @media (prefers-color-scheme: dark) {
+    body:not([data-theme='light']) {
+      --color-background-primary: var(--lt-color-bg, #131416);
+      --color-background-secondary: var(--lt-color-bg-secondary, #1a1c1e);
+      --color-background-hover: var(--lt-color-bg-hover, #1e2124);
+
+      --color-foreground-primary: var(--lt-color-fg, #cfd0d0);
+      --color-foreground-secondary: var(--lt-color-fg-secondary, #9ca0a5);
+      --color-foreground-muted: var(--lt-color-fg-muted, #81868d);
+
+      --color-background-border: var(--lt-color-border, #303335);
+
+      --color-brand-primary: var(--lt-color-accent, #3d94ff);
+      --color-brand-content: var(--lt-color-link, #5ca5ff);
+      --color-brand-visited: var(--lt-color-link-visited, #b27aeb);
+
+      --color-inline-code-background: var(--lt-color-code-bg, #1a1c1e);
+      --color-highlighted-background: var(--lt-color-highlighted-bg, #083563);
+
+      --color-api-added: var(--lt-color-added, #3db854);
+      --color-api-removed: var(--lt-color-removed, #ff7575);
+      --color-api-changed: var(--lt-color-changed, #09b0ce);
+      --color-api-deprecated: var(--lt-color-deprecated, #b1a10b);
+    }
+  }
+}
diff --git a/site/scripts/check-dev.mjs b/site/scripts/check-dev.mjs
index 207eef36..1c3066aa 100644
--- a/site/scripts/check-dev.mjs
+++ b/site/scripts/check-dev.mjs
@@ -7,7 +7,8 @@ import { dev } from 'astro'
 import { chromium, firefox, webkit } from 'playwright'
 import { PORTS, productAvailable } from '../src/lib/ports.ts'
 import { checkClipboard } from './check-clipboard.mjs'
-import { checkNavigation } from './check-navigation.mjs'
+import { checkApiNavigation, checkNavigation } from './check-navigation.mjs'
+import { checkNativeLayout } from './check-native-layout.mjs'
 
 const workspacePortCount = PORTS.filter((port) => productAvailable(port, 'workspace')).length
 // `workspaceCli` alone also covers a port's local, unreleased dev CLI
@@ -49,9 +50,10 @@ const terminate = async () => {
 }
 process.on('SIGTERM', terminate)
 process.on('SIGINT', terminate)
-server = await dev({ root, cacheDir: join(mirror, 'cache'),
+const startServer = () => dev({ root, cacheDir: join(mirror, 'cache'),
   vite: { cacheDir: join(mirror, 'vite') }, logLevel: 'error',
   server: { host: '127.0.0.1', port: 0 } })
+server = await startServer()
 const base = `http://127.0.0.1:${server.address.port}/en`
 
 // Vite can reload once after its initial dependency optimization.
@@ -69,6 +71,7 @@ try {
   const driver = { chromium, firefox, webkit }[engine]
   if (!driver) throw new Error(`Unknown browser: ${engine}`)
   browser = await driver.launch(engine === 'chromium' ? { channel: process.env.LIBTMUX_DOCS_BROWSER_CHANNEL } : {})
+  const nativeLayout = checkNativeLayout(browser).then(() => null, (error) => error)
   const page = await browser.newPage({ reducedMotion: 'reduce' })
   page.setDefaultTimeout(10000)
   const manifest = await page.request.get(`${base}/page-links.json`)
@@ -214,6 +217,8 @@ try {
   console.log('Empty sidebars: article and reference index use their available width')
   const clipboardError = await clipboard
   if (clipboardError) throw clipboardError
+  const nativeLayoutError = await nativeLayout
+  if (nativeLayoutError) throw nativeLayoutError
   await page.goto(`${base}/`, { waitUntil: 'load' })
   await page.locator('.scheme-switch input[value="dark"]').check({ force: true })
   const chipPixel = await page.evaluate(() => {
@@ -320,6 +325,14 @@ try {
     }
   }
   console.log('Heroes: 88px marks share the title row and stack at phone widths')
+  // Core API routes exist only in a port shell. Reuse the isolated fixture
+  // with its real Lua routes so the routine gate covers retained-document swaps.
+  await server.stop()
+  Object.assign(process.env, {
+    LIBTMUX_DOCS_PORT: 'lua', LIBTMUX_DOCS_BASE: '/en/lua/latest/',
+  })
+  server = await startServer()
+  await checkApiNavigation(page, `http://127.0.0.1:${server.address.port}/en`)
 } finally {
   await browser?.close()
   await server.stop()
diff --git a/site/scripts/check-mobile-nav.mjs b/site/scripts/check-mobile-nav.mjs
index 700ce729..be241358 100755
--- a/site/scripts/check-mobile-nav.mjs
+++ b/site/scripts/check-mobile-nav.mjs
@@ -22,12 +22,21 @@
  * Usage: node scripts/check-mobile-nav.mjs [base-url]
  */
 import { chromium } from 'playwright'
+import { checkApiNavigation } from './check-navigation.mjs'
 const BASE = (process.argv[2] ?? 'http://localhost:8080').replace(/\/$/, '')
 const b = await chromium.launch()
 const fails = [], ok = []
 const note = (pass, msg) => (pass ? ok : fails).push(msg)
 const WITH_TOC = '/topics/traversal/', NO_TOC = '/concepts/'
 const ctx = await b.newContext()
+const apiPage = await ctx.newPage()
+try {
+  await checkApiNavigation(apiPage, BASE)
+} catch (error) {
+  fails.push(`API navigation: ${error.message}`)
+} finally {
+  await apiPage.close()
+}
 async function page(path, w = 390) {
   const p = await ctx.newPage()
   await p.setViewportSize({ width: w, height: 800 })
diff --git a/site/scripts/check-native-layout.mjs b/site/scripts/check-native-layout.mjs
new file mode 100644
index 00000000..c585b2c5
--- /dev/null
+++ b/site/scripts/check-native-layout.mjs
@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { createServer } from 'node:http'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { normalizeNativeShell } from '../../scripts/normalize-native-shell.mjs'
+import { PORTS } from '../src/lib/ports.ts'
+
+/** Keep every port visible in a short language list at intermediate widths. */
+export async function checkNativeHeader(page) {
+  const navigation = await page.locator('.lt-shell-nav').evaluate((nav) => {
+    const links = [...nav.querySelectorAll('a')]
+    const bounds = links.map((link) => link.getBoundingClientRect())
+    return {
+      count: links.length,
+      rows: new Set(bounds.map((rect) => rect.top)).size,
+      visible: bounds.every((rect) => rect.width > 0 && rect.height > 0 && rect.left >= 0 && rect.right <= innerWidth),
+      covered: links.filter((link, i) => {
+        const rect = bounds[i]
+        return !link.contains(document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2))
+      }).map((link) => link.getAttribute('aria-label')),
+    }
+  })
+  assert.equal(navigation.count, PORTS.length, 'Native header keeps every port')
+  assert(navigation.rows <= 3, `Native ports use at most three rows at ${page.viewportSize().width}px: ${navigation.rows}`)
+  assert(navigation.visible, 'Native port links fit the viewport')
+  assert.deepEqual(navigation.covered, [], 'Native header controls do not cover port links')
+}
+
+/** Delay enhancement until the initial article and navigation can be inspected. */
+export async function checkNativeFirstPaint(page, url) {
+  let release
+  const delayedScript = new Promise((resolve) => { release = resolve })
+  const pendingRoutes = []
+  const routeScript = (route) => {
+    const pending = delayedScript.then(() => route.continue())
+    pendingRoutes.push(pending)
+    return pending
+  }
+  await page.route('**/_shell/shell.js', routeScript)
+  try {
+    const response = await page.goto(url, { waitUntil: 'commit' })
+    assert(response?.ok(), `Native page: HTTP ${response?.status()}`)
+    await page.locator('article h1').waitFor({ state: 'visible' })
+    assert(await page.locator('[data-lt-shell="header"]').isVisible(), 'Native header is visible before shell.js arrives')
+    assert.equal(await page.evaluate(() => customElements.get('libtmux-version-switcher') !== undefined), false,
+      'Native content and navigation are visible while shell.js is still unavailable')
+    await checkNativeHeader(page)
+    const initial = await page.locator('article h1').boundingBox()
+    await page.evaluate(() => { window.__initialNativeHeader = document.querySelector('[data-lt-shell="header"]') })
+    release()
+    await page.waitForLoadState('networkidle')
+    assert.deepEqual(await page.locator('article h1').boundingBox(), initial, `Native first paint stays still at ${page.viewportSize().width}px`)
+    assert(await page.evaluate(() => window.__initialNativeHeader === document.querySelector('[data-lt-shell="header"]')),
+      'Enhancement preserves the initial header')
+    assert.equal(await page.locator('[data-lt-shell="header"]').count(), 1)
+  } finally {
+    release()
+    await Promise.all(pendingRoutes)
+    await page.unroute('**/_shell/shell.js', routeScript)
+  }
+}
+
+/** Exercise the real native adapter before, during and after script loading. */
+export async function checkNativeLayout(browser) {
+  const directory = mkdtempSync(join(tmpdir(), 'native-first-paint-'))
+  const root = '/pr-42/en', version = 'v0.62.0', pagePath = `${root}/py/${version}/api/session/`
+  const pageFile = join(directory, 'session/index.html')
+  mkdirSync(join(directory, 'session'))
+  writeFileSync(pageFile, '<!doctype html><html><head><meta charset="utf-8"><style>body{margin:0;font:16px/1.5 Arial}article{padding:24px}h1{margin:0}</style></head><body><article><h1>Sessions</h1><p>Read the native reference while its controls load.</p><dt class="sig" id="libtmux.Session">Session</dt></article></body></html>')
+  let server
+  try {
+    await normalizeNativeShell(directory, root, { sphinxPort: 'py', version })
+    const assets = new Map([
+      [pagePath, ['text/html', readFileSync(pageFile)]],
+      [`${root}/py/${version}/api/_static/libtmux-org.css`, ['text/css', readFileSync(join(directory, '_static/libtmux-org.css'))]],
+      ...['shell.js', 'tokens.css'].map((file) => [`${root}/_shell/${file}`, [file.endsWith('.js') ? 'text/javascript' : 'text/css', readFileSync(new URL(`../public/_shell/${file}`, import.meta.url))]]),
+      [`${root}/versions.json`, ['application/json', JSON.stringify({ schema: 1, defaultVersion: { ts: 'stable' }, ports: {
+        py: [{ slug: version, label: version, supported: true }, { slug: 'v0.63.0rc1', label: 'v0.63.0rc1', supported: true }],
+      } })]],
+      [`${root}/page-links.json`, ['application/json', JSON.stringify({ schema: 1, symbols: { py: {} }, indexes: {} })]],
+    ])
+    server = createServer((request, response) => {
+      const asset = assets.get(request.url)
+      response.writeHead(asset ? 200 : 404, { 'Content-Type': asset?.[0] ?? 'text/plain', 'Cache-Control': 'no-store' })
+      response.end(asset?.[1] ?? 'Not found')
+    })
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
+    const url = `http://127.0.0.1:${server.address().port}${pagePath}`
+    for (const width of [1440, 768, 688, 390]) {
+      const context = await browser.newContext({ viewport: { width, height: 900 } })
+      try {
+        const page = await context.newPage()
+        await checkNativeFirstPaint(page, url)
+        assert.equal(await page.locator('libtmux-version-switcher option').count(), 2)
+        assert.equal(await page.locator('[data-port-home="ts"]').first().getAttribute('href'), `${root}/ts/stable/`)
+      } finally {
+        await context.close()
+      }
+      const noScript = await browser.newContext({ javaScriptEnabled: false, viewport: { width, height: 900 } })
+      try {
+        const page = await noScript.newPage()
+        await page.goto(url)
+        assert(await page.locator('article h1').isVisible())
+        await checkNativeHeader(page)
+        await page.locator('[data-page-port-switcher] summary').click()
+        assert(await page.locator('[data-page-port-switcher] a[aria-current]').isVisible(), 'Native disclosure works without JavaScript')
+      } finally {
+        await noScript.close()
+      }
+    }
+    console.log('Native first paint: compact header, visible content, stable geometry, enhanced controls and no-JS navigation at 1440/768/688/390px')
+  } finally {
+    if (server) await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()))
+    rmSync(directory, { recursive: true, force: true })
+  }
+}
diff --git a/site/scripts/check-native-shell.mjs b/site/scripts/check-native-shell.mjs
index 5ea3badb..8baa15a0 100644
--- a/site/scripts/check-native-shell.mjs
+++ b/site/scripts/check-native-shell.mjs
@@ -1,36 +1,54 @@
 #!/usr/bin/env node
 import assert from 'node:assert/strict'
 import { chromium } from 'playwright'
+import { checkNativeFirstPaint } from './check-native-layout.mjs'
 
 const base = (process.argv.find((arg) => arg.startsWith('http')) ?? 'http://localhost:8080/en').replace(/\/$/, '')
+const version = process.argv.find((arg) => arg.startsWith('--version='))?.slice('--version='.length) ?? 'stable'
 const browser = await chromium.launch({ channel: process.env.LIBTMUX_DOCS_BROWSER_CHANNEL })
 try {
-  const page = await browser.newPage({ viewport: { width: 390, height: 844 } })
+  const page = await browser.newPage()
   page.setDefaultTimeout(10000)
   const loaded = new Set()
   page.on('response', (response) => {
     if (response.ok()) loaded.add(response.url())
   })
-  const response = await page.goto(`${base}/py/stable/api/api/libtmux.session/`)
-  assert(response?.ok(), `Native Session page: HTTP ${response?.status()}`)
-  const menu = page.locator('[data-page-port-switcher]')
-  await menu.waitFor()
-  await page.waitForFunction(() => document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session/"]'))
-  assert(loaded.has(`${base}/_shell/shell.js`), 'Native shell script did not load from this locale')
-  assert(loaded.has(`${base}/_shell/tokens.css`), 'Native shell tokens did not load from this locale')
-  await menu.locator('summary').click()
-  const bounds = await menu.evaluate((details) => {
-    const current = details.querySelector('summary').getBoundingClientRect()
-    const locale = details.nextElementSibling.querySelector('summary').getBoundingClientRect()
-    const panel = details.querySelector('ul').getBoundingClientRect()
-    return { sameRow: Math.abs(current.y - locale.y) <= 1, left: panel.left, right: panel.right, viewport: innerWidth }
-  })
-  assert(bounds.sameRow && bounds.left >= 0 && bounds.right <= bounds.viewport, 'Native dropdowns split rows or leave the viewport')
+  for (const width of [1440, 768, 688, 390]) {
+    for (const colorScheme of ['light', 'dark']) {
+      await page.setViewportSize({ width, height: 900 })
+      await page.emulateMedia({ colorScheme })
+      await checkNativeFirstPaint(page, `${base}/py/${version}/api/api/libtmux.session/`)
+      const menu = page.locator('[data-page-port-switcher]')
+      await menu.waitFor()
+      await page.waitForFunction(() => document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session/"]'))
+      assert(loaded.has(`${base}/_shell/shell.js`), 'Native shell script did not load from this locale')
+      assert(loaded.has(`${base}/_shell/tokens.css`), 'Native shell tokens did not load from this locale')
+      await menu.locator('summary').focus()
+      await page.keyboard.press('Enter')
+      const bounds = await menu.evaluate((details) => {
+        const current = details.querySelector('summary').getBoundingClientRect()
+        const locale = details.nextElementSibling.querySelector('summary').getBoundingClientRect()
+        const panel = details.querySelector('ul')
+        const rect = panel.getBoundingClientRect()
+        const covered = [...panel.querySelectorAll('li')].filter((item) => {
+          const row = item.getBoundingClientRect()
+          return [rect.left + 12, rect.right - 12].some((x) => !item.contains(document.elementFromPoint(x, row.top + row.height / 2)))
+        }).map((item) => item.textContent.trim())
+        return { open: details.open, sameRow: Math.abs(current.y - locale.y) <= 1, left: rect.left, right: rect.right, viewport: innerWidth, covered }
+      })
+      const context = `${width}px ${colorScheme}`
+      assert(bounds.open, `${context}: keyboard did not open the port dropdown`)
+      assert(bounds.sameRow && bounds.left >= 0 && bounds.right <= bounds.viewport, `${context}: native dropdowns split rows or leave the viewport`)
+      assert.deepEqual(bounds.covered, [], `${context}: native content covers port menu entries`)
+      await page.keyboard.press('Enter')
+      assert.equal(await menu.evaluate((details) => details.open), false, `${context}: keyboard did not close the port dropdown`)
+    }
+  }
   await page.evaluate(() => { location.hash = 'sessions' })
   await page.waitForFunction(() => document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session/"]'))
   await page.evaluate(() => { location.hash = 'libtmux.Session.windows' })
   await page.waitForFunction(() => document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session-windows/"]'))
-  console.log('Native shell: script, tokens, phone dropdowns and class/member equivalents passed')
+  console.log('Native shell: compact header, stable first paint, assets, keyboard, unobscured dropdowns at 1440/768/688/390px in light/dark, and class/member equivalents passed')
 } finally {
   await browser.close()
 }
diff --git a/site/scripts/check-navigation.mjs b/site/scripts/check-navigation.mjs
index 105b93fb..653f797c 100644
--- a/site/scripts/check-navigation.mjs
+++ b/site/scripts/check-navigation.mjs
@@ -1,5 +1,70 @@
 import assert from 'node:assert/strict'
 
+/** Keep the API drawer usable after the router replaces the document. */
+export async function checkApiNavigation(page, base) {
+  const server = `${base}/lua/latest/reference/libtmux-server/`
+  const snapshot = `${base}/lua/latest/reference/libtmux-server-snapshot/`
+  for (const width of [688, 390]) {
+    await page.setViewportSize({ width, height: 759 })
+    await page.goto(server, { waitUntil: 'load' })
+    await page.waitForLoadState('networkidle')
+    await page.evaluate(() => { window.__apiNavigationProbe = true })
+    await page.locator('.api-member-link[href$="libtmux-server-snapshot/"]').click()
+    await page.waitForURL(snapshot)
+    assert(await page.evaluate(() => window.__apiNavigationProbe), 'API navigation retains the document')
+    assert(await page.locator('html').evaluate((el) => el.hasAttribute('data-api-nav')),
+      `API navigation restores the drawer styles at ${width}px`)
+    const nav = page.locator('#api-nav')
+    const toggle = page.locator('[data-api-nav-toggle]')
+    await nav.waitFor({ state: 'hidden' })
+    const open = async () => {
+      await toggle.click()
+      await page.waitForFunction(() => document.querySelector('#api-nav').getBoundingClientRect().left >= 0)
+      assert.equal(await toggle.getAttribute('aria-expanded'), 'true')
+    }
+    for (const close of ['button', 'Escape', 'overlay']) {
+      await open()
+      await nav.locator('[role="tree"]').evaluate((el) => { el.scrollTop = el.scrollHeight })
+      if (close === 'button') await nav.locator('[data-api-nav-close]').click()
+      else if (close === 'Escape') await page.keyboard.press('Escape')
+      else await page.locator('[data-api-nav-overlay]').click({ position: { x: width - 2, y: 400 } })
+      await nav.waitFor({ state: 'hidden' })
+      assert.equal(await toggle.getAttribute('aria-expanded'), 'false')
+      assert.equal(await page.evaluate(() => document.body.style.overflow), '')
+    }
+    await page.goBack()
+    await page.waitForURL(server)
+    await open()
+    const menu = nav.locator('.api-nav__menu')
+    const summary = menu.locator(':scope > summary')
+    const row = await summary.boundingBox(), section = await menu.boundingBox()
+    assert(Math.abs(row.y + row.height / 2 - section.y - section.height / 2) <= 1,
+      `Documentation disclosure is vertically centered at ${width}px`)
+    await summary.click()
+    assert.equal(await menu.evaluate((el) => el.open), true)
+    await summary.click()
+    assert.equal(await menu.evaluate((el) => el.open), false)
+    await nav.locator('[data-api-nav-close]').click()
+  }
+  for (const path of ['', 'guides/overview/']) {
+    await page.goto(`${base}/lua/latest/${path}`, { waitUntil: 'load' })
+    await page.locator('#mobile-sidebar-toggle').click()
+    await page.locator('#mobile-sidebar a[href$="/reference/"]').click()
+    await page.waitForURL(`${base}/lua/latest/reference/`)
+    await page.locator('.api-index-card__link[href$="/reference/libtmux-server/"]').click()
+    await page.waitForURL(server)
+    assert(await page.locator('[data-api-nav-toggle]').isVisible(), `${path || 'Port home'} to API keeps the drawer toggle`)
+    await page.locator('[data-api-nav-toggle]').click()
+    await page.locator('[data-api-nav-close]').click()
+    await page.locator('#api-nav').waitFor({ state: 'hidden' })
+  }
+  await page.setViewportSize({ width: 1440, height: 900 })
+  await page.locator('#api-nav').waitFor({ state: 'visible' })
+  assert.equal(await page.locator('#api-nav').evaluate((el) => el.inert), false)
+  assert.equal(await page.locator('[data-api-nav-toggle]').isVisible(), false)
+  console.log('API navigation: client swaps, Back, drawer close controls, disclosure alignment and desktop pass')
+}
+
 /** Check the controls attached to a document after its content is replaced. */
 export async function checkNavigation(page, base) {
   await page.goto(`${base}/examples/attach-and-send-keys/`, { waitUntil: 'load' })
diff --git a/site/src/components/PortHero.astro b/site/src/components/PortHero.astro
index 854cd711..108d3bf7 100644
--- a/site/src/components/PortHero.astro
+++ b/site/src/components/PortHero.astro
@@ -1,7 +1,7 @@
 ---
 import { branding } from '../lib/branding'
 import { withRoot } from '../lib/site-root'
-import { defaultVersionFor } from '../lib/versions'
+import { buildTarget, defaultVersionFor } from '../lib/versions'
 import PortLinks from './PortLinks.astro'
 import { hasReference, PORT_BY_SLUG, portPageUrl, type Port } from '../lib/ports'
 
@@ -29,6 +29,8 @@ interface Props {
 
 const { port } = Astro.props as Props
 const brand = branding(port.slug)
+const { version } = buildTarget(process.env)
+const revision = process.env.LIBTMUX_DOCS_PORT === port.slug ? process.env.LIBTMUX_DOCS_SOURCE_SHA : undefined
 ---
 
 <section class="port-hero max-w-4xl">
@@ -51,7 +53,7 @@ const brand = branding(port.slug)
     footer, pointing at the organisation rather than at this language, and the
     registry was nowhere.
   */}
-  <PortLinks port={port} class="mt-3" />
+  <PortLinks port={port} version={version} revision={revision} class="mt-3" />
 
   {
     hasReference(port) ? null : (
diff --git a/site/src/components/PortLinks.astro b/site/src/components/PortLinks.astro
index 62eeed07..ab537797 100644
--- a/site/src/components/PortLinks.astro
+++ b/site/src/components/PortLinks.astro
@@ -1,6 +1,6 @@
 ---
 import RegistryIcon from './icons/RegistryIcon.astro'
-import type { DocProduct, Port } from '../lib/ports'
+import { portSourceUrl, type DocProduct, type Port } from '../lib/ports'
 
 interface Props {
   port: Port
@@ -18,7 +18,9 @@ const repo = source?.repo ?? port.repo
 const taggedVersion = /^v?\d/.test(version) && repo === port.repo
   ? `${port.tagPrefix ?? ''}${version}` : undefined
 const ref = version === 'latest' ? source?.ref : taggedVersion ?? revision ?? source?.ref
-const sourceUrl = source ? `https://github.com/${repo}/tree/${ref}/${source.path}` : `https://github.com/${repo}`
+const sourceUrl = product
+  ? source ? `https://github.com/${repo}/tree/${ref}/${source.path}` : `https://github.com/${repo}`
+  : portSourceUrl(port, version, revision)
 const registry = product
   ? pkg?.registry && port.registry ? { ...port.registry, url: pkg.registry } : undefined
   : port.registry
diff --git a/site/src/components/SearchModal.astro b/site/src/components/SearchModal.astro
index eae0381f..4420b42d 100644
--- a/site/src/components/SearchModal.astro
+++ b/site/src/components/SearchModal.astro
@@ -1,6 +1,13 @@
 ---
 import SearchPanel from './SearchPanel.astro'
-import { withRoot } from '../lib/site-root'
+import { withPortRoot, withRoot } from '../lib/site-root'
+import { PORT_BY_SLUG } from '../lib/ports'
+
+interface Props {
+  port?: string
+  version: string
+}
+const { port, version } = Astro.props
 
 /**
  * Search without leaving the page.
@@ -10,11 +17,11 @@ import { withRoot } from '../lib/site-root'
  * /search/, and this intercepts the click — with no JavaScript the link still
  * works, which is why it is a link and not a button.
  */
-const searchHref = withRoot('/search/')
+const searchHref = port ? withPortRoot(`/${port}/${version}/search/`) : withRoot('/search/')
 ---
 
 <dialog id="search-modal" class="search-modal" aria-label="Search" data-search-href={searchHref}>
-  <SearchPanel modal />
+  <SearchPanel modal initialPort={port ? PORT_BY_SLUG[port]?.name : undefined} />
 </dialog>
 
 <style>
diff --git a/site/src/components/SearchPanel.astro b/site/src/components/SearchPanel.astro
index e0ec85e0..c984fb8c 100644
--- a/site/src/components/SearchPanel.astro
+++ b/site/src/components/SearchPanel.astro
@@ -24,11 +24,13 @@ interface Props {
   subResults?: SubResultsDisplay
   /** A query to run as soon as the panel mounts. */
   initialQuery?: string
+  /** Current port's Pagefind filter value. */
+  initialPort?: string
   /** Search a small built-in index instead of Pagefind's, for the demo. */
   mock?: boolean
 }
 
-const { modal = false, subResults, initialQuery, mock = false } = Astro.props as Props
+const { modal = false, subResults, initialQuery, initialPort, mock = false } = Astro.props as Props
 // A breadcrumb names a port as the site does, not by its slug.
 const segmentNames =
   subResults === 'breadcrumbs' ? JSON.stringify(Object.fromEntries(PORTS.map((port) => [port.slug, port.name]))) : undefined
@@ -40,6 +42,7 @@ const segmentNames =
   data-search-bundle={withRoot('/pagefind/')}
   data-sub-results={subResults}
   data-initial-query={initialQuery}
+  data-initial-port={initialPort}
   data-mock={mock ? '' : undefined}
   data-segment-names={segmentNames}
 >
@@ -53,7 +56,7 @@ const segmentNames =
       type="search"
       autocomplete="off"
       spellcheck="false"
-      placeholder="Search the documentation"
+      placeholder={initialPort ? `Search ${initialPort} documentation` : 'Search the documentation'}
       aria-label="Search"
     />
     {modal && <kbd class="search-panel__hint">Esc</kbd>}
@@ -351,6 +354,7 @@ const segmentNames =
       const handle = mountSearchPanel(root, bundle, {
         subResults: root.dataset.subResults as SubResultsDisplay | undefined,
         initialQuery: root.dataset.initialQuery,
+        initialPort: root.dataset.initialPort,
         mock,
         segmentNames: root.dataset.segmentNames ? (JSON.parse(root.dataset.segmentNames) as Record<string, string>) : undefined,
       })
diff --git a/site/src/components/SiteFooter.astro b/site/src/components/SiteFooter.astro
index da4a5e7d..2b35a7c4 100644
--- a/site/src/components/SiteFooter.astro
+++ b/site/src/components/SiteFooter.astro
@@ -17,13 +17,13 @@ interface Props {
   markdownHref: string
   /** The narrowest tree with its own docs.json and llms files. */
   llmsRoot: string
-  /** The repository behind the GitHub icon: this page's port, else this site. */
-  githubRepo: string
+  /** The source tree behind the GitHub icon: this page's library, else its repository. */
+  githubUrl: string
   /** No gap above: the page's columns run down to the footer's rule. */
   flush?: boolean
 }
 
-const { locale, source, markdownHref, llmsRoot, githubRepo, flush = false } = Astro.props
+const { locale, source, markdownHref, llmsRoot, githubUrl, flush = false } = Astro.props
 ---
 
 <footer class:list={[!flush && 'mt-16', 'border-t border-edge']}>
@@ -51,7 +51,7 @@ const { locale, source, markdownHref, llmsRoot, githubRepo, flush = false } = As
         <a class="muted-link underline" href={`${llmsRoot}llms-full.txt`}>llms-full.txt</a>
       </div>
       <div class="icons shrink-0">
-        <a class="muted-link" href={`https://github.com/${githubRepo}/`} aria-label="GitHub">
+        <a class="muted-link" href={githubUrl} aria-label="GitHub">
           <svg class="h-5 w-5" fill="currentColor" viewBox="0 0 16 16" aria-hidden="true"><path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z"></path></svg>
         </a>
       </div>
diff --git a/site/src/components/SiteHeader.astro b/site/src/components/SiteHeader.astro
index fc169e1d..6d5134a2 100644
--- a/site/src/components/SiteHeader.astro
+++ b/site/src/components/SiteHeader.astro
@@ -69,7 +69,7 @@ const brand = branding(portSlug, pagePath)
       <a href={withPortRoot('/reference/')} class="topnav-chip site-header__wide-link">Reference</a>
       <a href={withRoot('/mcp/')} class="topnav-chip site-header__wide-link">MCP</a>
       <a
-        href={withRoot('/search/')}
+        href={portSlug ? withPortRoot(`/${portSlug}/${version}/search/`) : withRoot('/search/')}
         class="topnav-chip site-header__search border border-edge"
         aria-label="Search the documentation"
       >
diff --git a/site/src/components/api/api-tree.ts b/site/src/components/api/api-tree.ts
index c98b2860..a66adb3b 100644
--- a/site/src/components/api/api-tree.ts
+++ b/site/src/components/api/api-tree.ts
@@ -364,7 +364,11 @@ export function initApiTree() {
   controller = new AbortController()
   const { signal } = controller
   // By class: <html> carries data-api-nav as the drawer's pre-paint flag.
-  document.querySelectorAll<HTMLElement>('.api-nav').forEach((nav) => {
+  const navs = document.querySelectorAll<HTMLElement>('.api-nav')
+  // ClientRouter replaces the html attributes without rerunning the inline
+  // pre-paint script. Restore the enhancement before initializing the drawer.
+  document.documentElement.toggleAttribute('data-api-nav', navs.length > 0)
+  navs.forEach((nav) => {
     const tree = nav.querySelector<HTMLElement>('[role="tree"]')
     if (tree) initTree(nav, tree, signal)
     initDrawer(nav, signal)
diff --git a/site/src/content.config.ts b/site/src/content.config.ts
index 7d5965bc..b3fee73c 100644
--- a/site/src/content.config.ts
+++ b/site/src/content.config.ts
@@ -2,6 +2,7 @@ import { glob } from 'astro/loaders'
 import { defineCollection } from 'astro:content'
 import { z } from 'astro/zod'
 import { workspaceDocsLoader } from './loaders/workspace-shared.ts'
+import { PORTS } from './lib/ports.ts'
 
 /**
  * Shell prose. One collection for everything hand-written: the landing page,
@@ -25,6 +26,8 @@ const docs = defineCollection({
     description: z.string().optional(),
     /** Restricts a page to one port's section, e.g. 'py'. Omit for shared pages. */
     port: z.string().optional(),
+    /** Shared prose is published only where its native APIs are documented. */
+    supportedPorts: z.array(z.string().refine((slug) => PORTS.some((port) => port.slug === slug), 'Unknown documentation port')).optional(),
     /** Product pages are authored separately for each port. */
     product: z.enum(['mcp', 'workspace']).optional(),
     /** Published package a staged source guide documents. */
diff --git a/site/src/content/_workspace-shared/workspace/cli/completion.md b/site/src/content/_workspace-shared/workspace/cli/completion.md
index 7d379d16..60a0e49a 100644
--- a/site/src/content/_workspace-shared/workspace/cli/completion.md
+++ b/site/src/content/_workspace-shared/workspace/cli/completion.md
@@ -1,5 +1,5 @@
 ---
-description: Generate completion from command definitions and check native availability.
+description: Generate completion for the installed workspace command.
 product: workspace
 sidebar:
   group: CLI reference
@@ -7,92 +7,121 @@ sidebar:
   order: 22
 tableOfContents: true
 title: Shell completion
-ports:
-  py:
-    description: Generate completion from the Python parser and track native generator requirements.
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-tmuxp uses the separately installed `shtab` package for experimental completion. The parser entry point is [`tmuxp.cli.create_parser`](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py). Generate a script in an environment that can import both packages, then use the shell-specific installation procedure from the [upstream completion guide](https://tmuxp.git-pull.com/cli/completion/).
+<!-- port:py -->
+tmuxp uses the optional `shtab` package to generate experimental shell completion
+from its argparse definitions. Install it in the same Python environment as
+tmuxp, then follow the [completion setup](https://tmuxp.git-pull.com/cli/completion/)
+for your shell.
 
-<!-- port:py -->There is no native workspace executable to generate completions from in this
-prototype. The proposed parser choices provide different generators: Cobra has
-command-tree completion and documentation export, clap has completion and
-man-page companions, ArgumentParser has completion and documentation tools,
-picocli has code generation, and Commander, System.CommandLine, and CLI11 need
-their documented tooling or an explicit metadata adapter.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->## Native completion
+Generate the script again after upgrading tmuxp so it matches the installed
+parser. The parser is available through `tmuxp.cli.create_parser`.
 
-<!-- /port --><!-- port:ts -->Commander defines the native command graph. The CLI package generates Markdown,
-a JSON command catalog, and Bash, Zsh, and Fish completion from those definitions.
-`docs:check` compares generated files in CI. Keep option event order when paired
-flags share a destination.
-<!-- /port --><!-- port:rs -->Clap defines the native command graph. `--generate schema` exports metadata;
-`--generate man` renders the root manual. `--generate` also accepts `bash`, `zsh`,
-`fish`, `powershell`, and `elvish` through clap_complete. Separate subcommand
-manuals are not generated.
-<!-- /port --><!-- port:go -->Cobra defines the native command graph. `--command-tree` exports JSON metadata;
-`--generate-docs` accepts `markdown`, `man`, or `yaml`.
-`--generate-completion` accepts `bash`, `zsh`, `fish`, or `powershell`. Exports
-distinguish command-local flags from inherited machine-output options.
-<!-- /port --><!-- port:java -->Picocli defines the native command graph. `--generate schema` exports metadata
-and `--generate bash` emits completion through its code generator. Other manual
-and completion formats are not exposed by the workspace executable.
-<!-- /port --><!-- port:cxx -->The local C++ CLI generates Bash, Zsh and Fish completion. Build it through
-[installation](../../guides/installation/) and make the resulting
-`tmux-workspace` executable available on `PATH`.
-<!-- /port --><!-- port:java,cxx -->
-<!-- /port --><!-- port:java -->Normal Bash generation writes the script directly. Add `--json` for a versioned
-artifact with `"command": "generate"`, `"format": "bash"`, the exact text in
-`"script"`, and `"status": "ok"`. `--ndjson` emits that artifact as one
-`completed` event with `"sequence": 1` and takes precedence over `--json`.
-Schema generation retains its metadata document in every output mode. See the
-[native generation contract](https://github.com/libtmux/libtmux-java/blob/887a5e079d38898bdffaad19a7961936eabe1ce0/workspace-cli/README.md#generated-reference-and-development).
-<!-- /port --><!-- port:dotnet -->System.CommandLine defines the native command graph. `--generate reference`
-exports its metadata; `--generate man`, `bash`, `zsh`, and `fish` render the other
-formats. The completion scripts offer command and option names without full
-argument context. Spectre.Console owns human presentation separately.
-<!-- /port --><!-- port:cxx -->Enable Bash completion in the current shell:
-<!-- /port --><!-- port:swift -->ArgumentParser defines the native command graph and supplies
-`--generate-completion-script` for shell completion. Manual, DocC, and site
-metadata integration remain separate work. Use supported parser APIs for those
-exports; private parser reflection is not a stable contract.
-<!-- /port -->
-<!-- port:py,ts,rs,go,java,dotnet,swift -->Completion is derived from actual command metadata. It must include nested
-import commands, local short flags, positional arity, mutually exclusive
-<!-- /port --><!-- port:py -->choices, and all-command machine options once implemented. Do not ship a static
-completion script for a guessed executable name.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,swift -->choices, and all-command machine options. Verify generated scripts with the installed
-executable and target shell.
-<!-- /port --><!-- port:cxx -->```console
-$ source <(tmux-workspace --generate-completion bash)
-```
+[Parser source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
 
-For Zsh, initialise its completion system and load the generated script:
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Generate completion using the installed `tmux-workspace` command. The script
+matches that executable's command definitions.
 
+## Enable Bash completion
+
+<!-- port:ts -->
 ```console
-$ autoload -Uz compinit && compinit && source <(tmux-workspace --generate-completion zsh)
+$ tmux-workspace completion bash > tmux-workspace.bash
 ```
+<!-- /port -->
+<!-- port:rs -->
+```console
+$ tmux-workspace --generate bash > tmux-workspace.bash
+```
+<!-- /port -->
+<!-- port:go -->
+```console
+$ tmux-workspace --generate-completion bash > tmux-workspace.bash
+```
+<!-- /port -->
+<!-- port:java -->
+```console
+$ tmux-workspace --generate bash > tmux-workspace.bash
+```
+<!-- /port -->
+<!-- port:dotnet -->
+```console
+$ tmux-workspace --generate bash > tmux-workspace.bash
+```
+<!-- /port -->
+<!-- port:cxx -->
+```console
+$ tmux-workspace --generate-completion bash > tmux-workspace.bash
+```
+<!-- /port -->
+<!-- port:swift -->
+```console
+$ tmux-workspace --generate-completion-script bash > tmux-workspace.bash
+```
+<!-- /port -->
 
-For Fish:
+Check the generated script before loading it in your current Bash session:
 
 ```console
-$ tmux-workspace --generate-completion fish | source
+$ bash -n tmux-workspace.bash
 ```
 
-Completion includes nested import commands, command-specific flags, enumerated
-values and file paths, including names containing spaces. It does not start
-tmux or read workspace files. Dynamic session names and configuration aliases
-are not suggested. Add the matching setup command to your shell configuration
-to enable completion in later sessions.
+```bash
+source ./tmux-workspace.bash
+```
+
+Keep the script in your shell's completion directory to load it in later
+sessions. Regenerate it after upgrading the CLI.
+
+## Other shells
 
-This is part of the unreleased native CLI. The documentation exporter remains
-separate from shell completion.
+<!-- port:ts -->
+`completion zsh` and `completion fish` generate the other supported shells.
+<!-- /port -->
+<!-- port:rs -->
+`--generate` also accepts `zsh`, `fish`, `powershell` and `elvish`.
+<!-- /port -->
+<!-- port:go -->
+`--generate-completion` also accepts `zsh`, `fish` and `powershell`.
+<!-- /port -->
+<!-- port:java -->
+The CLI provides Bash completion.
+<!-- /port -->
+<!-- port:dotnet -->
+`--generate zsh` and `--generate fish` generate the other supported shells.
+<!-- /port -->
+<!-- port:cxx -->
+`--generate-completion` also accepts `zsh` and `fish`.
 <!-- /port -->
-See the [command tree](../) and [compatibility
-reference](../../reference/compatibility/).
+<!-- port:swift -->
+`--generate-completion-script` also accepts `zsh` and `fish`.
+<!-- /port -->
+
+Follow the selected shell's completion setup before sourcing its script.
+Generating a script does not start tmux or load workspace files.
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/convert.md b/site/src/content/_workspace-shared/workspace/cli/convert.md
index d6e9b172..06ee0425 100644
--- a/site/src/content/_workspace-shared/workspace/cli/convert.md
+++ b/site/src/content/_workspace-shared/workspace/cli/convert.md
@@ -1,26 +1,22 @@
 ---
-description: Convert a workspace document between YAML and JSON while retaining its mapping keys. Conversion does not prove that a native builder supports every retained field.
+description: Convert a complete workspace document between YAML and JSON.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp convert
+  label: Convert workspace files
   order: 12
 tableOfContents: true
-title: tmuxp convert
+title: Convert workspace files
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Convert a workspace document between YAML and JSON while retaining its mapping
-keys. Conversion does not prove that a native builder supports every retained
-field.
+keys.
 
 ## Change the file format
 
-Given the [`workspace.yaml`](../../guides/installation/#create-the-input) from the [installation
-walkthrough](../../guides/installation/), convert it to [`workspace.json`](./):
+Given `workspace.yaml` from the [installation
+walkthrough](../../guides/installation/):
 
 ```console
 $ tmuxp convert \
@@ -28,30 +24,67 @@ $ tmuxp convert \
     workspace.yaml
 ```
 
-The destination has the same stem and opposite extension. In the reference,
-`--yes` permits replacement of an existing destination without an additional
-existence check. The original input remains. YAML comments and textual
-formatting do not round-trip through JSON.
+The destination has the same stem and opposite extension. `--yes` permits
+replacement of an existing destination. The original input remains. YAML
+comments and textual formatting do not round-trip through JSON.
 
-Conversion uses the complete document mapping. A serializer for a reduced native
-workspace struct can silently discard extension keys and is insufficient for
-<!-- port:py -->this command. The proposed native machine mode returns a document without
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->this command. The native machine mode returns a document without
-<!-- /port -->writing a guessed destination; its extra save and overwrite controls are
-described in [output](../../reference/output/).
+The command resolves a file or saved workspace name.
+[Discovery](../../guides/discovery/) describes that lookup.
 
-## Arguments and flags
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/convert.py).
+<!-- /port -->
 
-| Argument or flags | Arity / default | Choices or meaning |
-| --- | --- | --- |
-| `workspace_file` | required | checks tmuxp and current directory for workspace files. |
-| `--yes`, `-y` | flag; False | always answer yes |
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Convert a complete workspace document between YAML and JSON. Conversion
+preserves mapping fields; it does not establish that every field can be loaded.
 
-All commands accept `-h` / `--help`. Root options precede the command; see the
-[CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
-<!-- /port -->
-[Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/convert.py).
+## Inspect the result
+
+Start with `workspace.yaml` from the [installation
+walkthrough](../../guides/installation/):
+
+```console
+$ tmux-workspace convert --json workspace.yaml
+```
+
+Without a destination, machine mode returns the converted document in its
+result. YAML comments and textual formatting do not survive conversion to JSON.
+
+## Save a file
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+Choose an explicit destination and encoding:
+
+```console
+$ tmux-workspace convert \
+    --json \
+    --workspace-format json \
+    --save-to workspace.json \
+    workspace.yaml
+```
+
+Replacing an existing destination requires `--force`. Keep that choice separate
+from `--yes`, which answers prompts. Review the result before [loading
+it](../load/).
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/debug-info.md b/site/src/content/_workspace-shared/workspace/cli/debug-info.md
index de5c5a1f..f62996ba 100644
--- a/site/src/content/_workspace-shared/workspace/cli/debug-info.md
+++ b/site/src/content/_workspace-shared/workspace/cli/debug-info.md
@@ -1,22 +1,18 @@
 ---
-description: Collect tmuxp, Python, tmux, configuration, and environment diagnostics for troubleshooting.
+description: Collect the workspace CLI runtime, configuration and tmux diagnostics..
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp debug-info
+  label: Inspect runtime diagnostics
   order: 14
 tableOfContents: true
-title: tmuxp debug-info
+title: Inspect runtime diagnostics
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-Collect tmuxp, Python, tmux, configuration, and environment diagnostics for
-troubleshooting.
+<!-- port:py -->
+Collect tmuxp, Python, tmux, configuration and environment diagnostics.
 
-## Inspect structured diagnostics
+## Collect a report
 
 ```console
 $ tmuxp debug-info --json
@@ -24,25 +20,49 @@ $ tmuxp debug-info --json
 
 The command writes one JSON object. Named path fields mask the home directory,
 but raw tmux output arrays are preserved. Review diagnostics before sharing them
-because names, commands, and raw tmux values may identify your environment.
+because names, commands and raw values may describe your environment.
+
+See [troubleshooting](../../guides/troubleshooting/) for connection and
+configuration failures.
 
-<!-- port:py -->`--ndjson` is a proposed native extension. The native result should name the
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->`--ndjson` is a native extension. The native result should name the
-<!-- /port -->port and runtime and define redaction for raw values. See
-[troubleshooting](../../guides/troubleshooting/) and
-[output](../../reference/output/).
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/debug_info.py).
+<!-- /port -->
 
-## Arguments and flags
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Collect the workspace CLI runtime, configuration and tmux diagnostics.
 
-| Argument or flags | Arity / default | Choices or meaning |
-| --- | --- | --- |
-| `--json` | flag; False | output as JSON |
+## Collect a report
 
-All commands accept `-h` / `--help`. Root options precede the command; see the
-[CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
-<!-- /port -->
-[Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/debug_info.py).
+```console
+$ tmux-workspace debug-info --json
+```
+
+Review the report before sharing it. Paths, session names and raw tmux values
+can describe your environment even when home-directory prefixes are redacted.
+Use the failed command exit status and stderr to diagnose its actual failure.
+
+See [troubleshooting](../../guides/troubleshooting/) and the [machine output
+reference](../../reference/output/).
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/edit.md b/site/src/content/_workspace-shared/workspace/cli/edit.md
index 1361039d..f82c4291 100644
--- a/site/src/content/_workspace-shared/workspace/cli/edit.md
+++ b/site/src/content/_workspace-shared/workspace/cli/edit.md
@@ -1,51 +1,77 @@
 ---
-description: Resolve a saved workspace or file and open it in the configured editor. The lookup rules are shared with loading.
+description: Resolve a workspace file or saved name and open it in an editor.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp edit
+  label: Edit a workspace
   order: 13
 tableOfContents: true
-title: tmuxp edit
+title: Edit a workspace
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-Resolve a saved workspace or file and open it in the configured editor. The
-lookup rules are shared with loading.
+<!-- port:py -->
+Resolve a saved workspace or file and open it in the configured editor.
 
 ## Open a workspace
 
-With [`workspace.yaml`](../../guides/installation/#create-the-input) already saved and `$EDITOR` set to a single executable:
+With `workspace.yaml` saved and `vi` installed:
 
 ```console
-$ tmuxp edit workspace.yaml
+$ EDITOR=vi tmuxp edit workspace.yaml
 ```
 
-The reference passes the entire `$EDITOR` value as one executable string followed
-by the file path. An editor command containing arguments is not tokenized. It
-waits for the child process but does not propagate that child's exit status. Use
-an editor wrapper executable when arguments are needed.
+The command passes the entire `EDITOR` value as one executable name followed by
+the file path. It does not split editor arguments. Use a wrapper executable when
+arguments are needed.
+
+The command waits for the editor but does not propagate its exit status. Inspect
+the edited file before loading it. [Discovery](../../guides/discovery/) explains
+saved workspace names.
 
-<!-- port:py -->The proposed native contract defines argument parsing and propagates child
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->The native contract defines argument parsing and propagates child
-<!-- /port -->failure. These are deliberate behavior changes, not existing Python guarantees.
-See [discovery](../../guides/discovery/) and
-[environment](../../configuration/environment/).
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/edit.py).
+<!-- /port -->
 
-## Arguments and flags
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Resolve a workspace file or saved name and open it in an editor. Use an explicit
+path when editing a particular file.
 
-| Argument or flags | Arity / default | Choices or meaning |
-| --- | --- | --- |
-| `workspace_file` | required | checks current tmuxp and current directory for workspace files. |
+## Open the file
 
-All commands accept `-h` / `--help`. Root options precede the command; see the
-[CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
+With `vi` installed and `workspace.yaml` saved:
+
+```console
+$ EDITOR=vi tmux-workspace edit workspace.yaml
+```
+
+<!-- port:cxx -->
+`VISUAL` takes precedence over `EDITOR`. Unset it or select the same editor there when using the command above.
 <!-- /port -->
-[Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/edit.py).
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+The CLI waits for the editor and reports a failed child through its exit status.
+Editor values can contain quoted arguments. They are parsed as an argument list;
+shell pipelines and redirection require an explicit shell or wrapper.
+
+[Discovery](../../guides/discovery/) explains saved workspace names.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/freeze.md b/site/src/content/_workspace-shared/workspace/cli/freeze.md
index a6ed6f6e..44813ee4 100644
--- a/site/src/content/_workspace-shared/workspace/cli/freeze.md
+++ b/site/src/content/_workspace-shared/workspace/cli/freeze.md
@@ -1,29 +1,22 @@
 ---
-title: "tmuxp freeze"
-description: "Capture a live session as a starting workspace file. A capture records observable session state; it cannot recover the original scripts, plugin intent, comments, or every application state."
+title: Capture a workspace
+description: Capture a running tmux session as a starting point for a workspace file.
 product: workspace
 sidebar:
-  label: "tmuxp freeze"
+  label: Capture a workspace
   group: "CLI reference"
   order: 11
 tableOfContents: true
 ---
-<!-- port:py -->
-This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port -->
-<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
 
-Capture a live session as a starting workspace file. A capture records
-observable session state; it cannot recover the original scripts, plugin intent,
-comments, or every application state.
+<!-- port:py -->
+Capture a running tmux session as a starting workspace file. A capture cannot
+recover original scripts, plugin intent, comments or every application state.
 
 ## Export a named session
 
 After the [installation walkthrough](../../guides/installation/) creates
-`workspace-guide`, export it to a new destination:
+`workspace-guide`, choose a new destination:
 
 ```console
 $ tmuxp freeze \
@@ -34,60 +27,76 @@ $ tmuxp freeze \
     workspace-guide
 ```
 
-Without a session argument, tmuxp resolves or asks for a live session. Without a
-format or destination, it can ask for those choices. `--yes` answers yes/no
-questions; it does not supply every missing selection. `--quiet` suppresses explanatory status, but prompts can still occur.
-Successful export writes the workspace document to a file, not stdout.
-Declining a confirmation can return without saving.
-
-In this reference, an explicit `--save-to` path bypasses the overwrite
-confirmation used by the prompted path. Select a new path deliberately. The
-<!-- port:py -->proposed native<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->native<!-- /port --> contract applies the same protection to explicit and prompted
-destinations and keeps `--force` distinct from `--yes`.
-
-Inspect the capture before reloading. See the [export and reload
-workflow](../../guides/export-session/) and the [<!-- port:py -->proposed machine<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->native machine<!-- /port -->
-output](../../reference/output/) for the distinction between a saved file's
-format and a CLI result stream.
-<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Without a session, format or destination, the command can ask for missing
+choices. `--yes` answers yes/no questions; it does not supply every choice.
+`--quiet` suppresses explanatory status but can still allow prompts.
 
-## What the captured document holds
+An explicit `--save-to` path bypasses the overwrite confirmation used by the
+prompted path. Select a new path deliberately. A successful export writes a
+file; declining a confirmation can return without saving.
 
-The seven native ports agree on three things a capture records, and on one it
-does not.
+Inspect the captured commands and paths before following [export and
+reload](../../guides/export-session/).
 
-**Window options are written under `options_after`.** tmux applies them after
-the panes exist, and options like `automatic-rename: off` do not hold if they
-are applied before. `load` accepts either spelling.
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/freeze.py).
+<!-- /port -->
 
-**A pane sitting at a shell gets no `shell_command`.** Naming the shell would
-start a shell inside a shell when the document is reloaded. The shell is
-recognised by name as well as by the session's `default-shell`, because macOS
-runs bash for `/bin/sh` and the pane reports `bash`.
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Capture a running tmux session as a starting point for a workspace file. Capture
+reads live state. It cannot recover original command arguments, command history,
+script definitions or plugin intent.
 
-**Nothing about the machine it was captured on.** No session environment, so a
-document does not carry the capturing host's `SSH_AUTH_SOCK` or `DISPLAY`, and
-no `default-size`, which would otherwise pin a reloaded session to the size of
-the terminal that captured it.
-<!-- /port -->
+## Inspect a session
 
-## Arguments and flags
+After the [installation walkthrough](../../guides/installation/) creates
+`workspace-guide`, request a machine result from its private socket:
 
-| Argument or flags | Arity / default | Choices or meaning |
-| --- | --- | --- |
-| `"session_name"` | optional |  |
-| `-S` | value; None | pass-through for tmux -S |
-| `-L` | value; None | pass-through for tmux -L |
-| `-f`, `--workspace-format` | value; None | yaml, json |
-| `-o`, `--save-to` | value; None | file to save to |
-| `--yes`, `-y` | flag; False | always answer yes |
-| `--quiet`, `-q` | flag; False | suppress explanatory/status text; prompts still occur despite the parser help claiming otherwise |
-| `--force` | flag; False | overwrite the workspace file |
+```console
+$ tmux-workspace freeze \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    --json \
+    workspace-guide
+```
 
-All commands accept `-h` / `--help`. Root options precede the command; see the
-[CLI overview](../). The [output reference](../../reference/output/)
-distinguishes current Python flags from <!-- port:py -->proposed all-command<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->native all-command<!-- /port --> JSON and NDJSON.
+## Save the captured document
 
-[Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/freeze.py).
+Name the destination and format explicitly:
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+```console
+$ tmux-workspace freeze \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    --json \
+    --workspace-format yaml \
+    --save-to captured-workspace.yaml \
+    workspace-guide
+```
+
+Use a new destination, or pass `--force` to authorize replacement. Review
+captured commands and directories before loading the file on another machine.
+The saved document encoding is separate from the CLI result format selected by
+`--json` or `--ndjson`.
+
+See [export and reload](../../guides/export-session/) for the complete workflow.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/import-teamocil.md b/site/src/content/_workspace-shared/workspace/cli/import-teamocil.md
index 03c82dc5..357c9077 100644
--- a/site/src/content/_workspace-shared/workspace/cli/import-teamocil.md
+++ b/site/src/content/_workspace-shared/workspace/cli/import-teamocil.md
@@ -1,18 +1,15 @@
 ---
-description: Translate a Teamocil workspace into tmuxp configuration, review the result, and select its saved representation.
+description: Translate Teamocil windows and pane commands into a workspace document.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp import teamocil
+  label: Import from Teamocil
   order: 19
 tableOfContents: true
-title: tmuxp import teamocil
+title: Import from Teamocil
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Translate a Teamocil workspace into tmuxp configuration, review the result, and
 select its saved representation.
 
@@ -29,47 +26,14 @@ although its positional action has optional arity, it belongs to a required
 exclusive group, and omission exits 2. The reference previews and saves the
 transformed document interactively.
 
-Native automation needs explicit destination, encoding, and overwrite policy
-instead of implicit prompts. See [output](../../reference/output/). Inspect
-translated commands and directories before loading the result.
+Inspect translated commands and directories before loading the result. See
+[output](../../reference/output/) for the command's formats.
 
 An extensionless name searches the configured source directory. A filename
 with an extension is resolved relative to the current directory unless you
 provide an explicit path.
 
-<!-- port:dotnet -->## Native .NET translation
-<!-- /port --><!-- port:cxx -->## Native C++ translation
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->`tmux-workspace import teamocil` accepts a session mapping, including the
-`session` wrapper. It preserves names, roots, layouts, window options and
-the first true window/pane focus flag in each scope.
-<!-- /port --><!-- port:cxx -->`tmux-workspace import teamocil` preserves names, roots, layouts, window
-options and pane/window focus. It accepts pane command strings and `commands`
-mappings. Command arrays join into one semicolon-separated shell input; the
-first true focus flag wins in each scope.
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->Each `panes` item creates one pane. A pane command string or `commands` list
-becomes one shell input; list entries join with `; ` to retain their command
-group. The aliases `tabs`, `splits` and `cmd` are accepted for `windows`,
-`panes` and `commands`. Null aliases fall back to the other spelling;
-conflicting non-null values fail validation.
-<!-- /port --><!-- port:cxx -->The legacy `session` wrapper and `project_name`, `project_root`, `tabs`,
-`splits` and `cmd` aliases are accepted. Null aliases fall back to the other
-spelling; conflicting non-null values are refused. An omitted session name
-uses the source filename stem.
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->Window options apply before command delivery, including `synchronize-panes`.
-Synchronized commands can therefore also reach panes created earlier in the
-same window. Filters, `clear` and unsupported pane-width fields are refused
-instead of being discarded. See [native import saving](../import/#native-net-imports)
-for roots, output and validation behavior.
-<!-- /port --><!-- port:cxx -->Relative roots resolve against the directory where import runs and are saved
-as absolute paths. Dollar expansion and `~user` paths are unsupported.
-Enabled `synchronize-panes` is refused because the native builder creates all
-panes before sending commands, changing which panes would receive input.
-See [native import saving](../import/#native-c-imports).
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port -->## Arguments and flags
+## Arguments and flags
 
 | Argument or flags | Arity / default | Choices or meaning |
 | --- | --- | --- |
@@ -77,9 +41,70 @@ See [native import saving](../import/#native-c-imports).
 
 All commands accept `-h` / `--help`. Root options precede the command; see the
 [CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
-<!-- /port -->
+describes the formats supported by each command.
 [Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/import_config.py).
 
 [tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Import a Teamocil file without starting tmux. Save this source as `teamocil.yaml`:
+
+```yaml title="teamocil.yaml"
+session:
+  name: imported-team
+  windows:
+    - name: editor
+      layout: even-horizontal
+      panes:
+        - commands: [printf ready]
+        - commands: [printf second]
+```
+
+## Preview the translation
+
+```console
+$ tmux-workspace import teamocil --json ./teamocil.yaml
+```
+
+The translated document preserves window and pane order. Several commands in
+one Teamocil `commands` list become one semicolon-separated shell input in that
+pane. Review the absolute working directories selected by the import.
+
+## Save the workspace
+
+```console
+$ tmux-workspace import teamocil \
+    --json \
+    --workspace-format yaml \
+    --save-to imported-teamocil.yaml \
+    ./teamocil.yaml
+```
+
+Use `--force` only to replace an existing destination deliberately. Unsupported
+fields, such as pane widths and filters, fail before saving. Conversion does
+not prove that a command or directory will be available when you
+[load](../load/) the result.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/import-tmuxinator.md b/site/src/content/_workspace-shared/workspace/cli/import-tmuxinator.md
index 8d4264f3..de008ffe 100644
--- a/site/src/content/_workspace-shared/workspace/cli/import-tmuxinator.md
+++ b/site/src/content/_workspace-shared/workspace/cli/import-tmuxinator.md
@@ -1,18 +1,15 @@
 ---
-description: Translate a tmuxinator workspace into tmuxp configuration, preserving an explicit boundary around dynamic Ruby configuration.
+description: Translate a tmuxinator project into a workspace document.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp import tmuxinator
+  label: Import from tmuxinator
   order: 20
 tableOfContents: true
-title: tmuxp import tmuxinator
+title: Import from tmuxinator
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Translate a tmuxinator workspace into tmuxp configuration, preserving an
 explicit boundary around dynamic Ruby configuration.
 
@@ -30,8 +27,7 @@ optional-looking help. The reference previews and saves the transformed document
 interactively.
 
 Do not interpret successful YAML parsing as support for ERB templates or
-arbitrary Ruby execution. Native importers must either implement a documented
-bridge or reject unsupported dynamic input. Inspect the resulting commands and
+arbitrary Ruby execution. Inspect the resulting commands and
 directories before loading. See [environment](../../configuration/environment/)
 and [output](../../reference/output/).
 
@@ -39,49 +35,7 @@ An extensionless name searches the configured source directory. A filename
 with an extension is resolved relative to the current directory unless you
 provide an explicit path.
 
-<!-- port:dotnet -->## Native .NET translation
-<!-- /port --><!-- port:cxx -->## Native C++ translation
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->`tmux-workspace import tmuxinator` keeps a shorthand window command list in
-one pane, with commands delivered in order. An explicit `panes` list creates
-separate panes; a command list inside one item still belongs to that pane.
-Named pane mappings are refused because the native workspace cannot preserve
-their titles.
-<!-- /port --><!-- port:cxx -->`tmux-workspace import tmuxinator` translates session names, project roots,
-named windows, layouts and pane commands. A command array used as a window
-body remains one pane with ordered commands; explicit panes may each contain
-a command array.
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->Project `pre_window` groups join with `; ` and run in each pane. Window `pre`
-groups join with ` && ` before that window's pane commands and require explicit
-nonempty panes. Project `pre` and launcher lifecycle hooks are refused: their
-launcher-shell timing cannot be preserved as pane commands. The importer
-accepts `rbenv` or `rvm` selectors as a per-pane prefix when no `pre_window`
-group is also selected.
-<!-- /port --><!-- port:cxx -->`pre_window` arrays join with `; `, while window `pre` arrays join with ` && `.
-A nonempty window `pre` requires explicit nonempty panes. Synchronization is
-supported only with `synchronize: after`. Host lifecycle hooks, ERB templates,
-named pane titles, startup selectors and endpoint/attachment settings are
-refused before saving.
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->`synchronize: true` and `synchronize: before` enable window synchronization
-before commands; `synchronize: after` enables it after initial commands.
-`false`, `off` and `0` do not enable synchronization through the import.
-Before synchronization can broadcast commands to panes created earlier in
-the window.
-
-The aliases `project_name`, `project_root`, `tabs`, `pre_tab` and `cli_args`
-are accepted for `name`, `root`, `windows`, `pre_window` and `tmux_options`.
-`socket_name` is preserved. `tmux_options` accepts only `-f PATH`, which selects
-the tmux configuration file. Other options, conflicting non-null aliases and
-unsupported fields are refused before saving. See
-[native import saving](../import/#native-net-imports) for roots and output.
-<!-- /port --><!-- port:cxx -->Relative project roots resolve where import runs; relative window roots
-resolve against the project root. Saved paths are absolute. `project_name`,
-`project_root` and `tabs` aliases use non-null fallback and refuse conflicts.
-See [native import saving](../import/#native-c-imports).
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port -->## Arguments and flags
+## Arguments and flags
 
 | Argument or flags | Arity / default | Choices or meaning |
 | --- | --- | --- |
@@ -89,9 +43,67 @@ See [native import saving](../import/#native-c-imports).
 
 All commands accept `-h` / `--help`. Root options precede the command; see the
 [CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
-<!-- /port -->
+describes the formats supported by each command.
 [Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/import_config.py).
 
 [tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Import a saved tmuxinator project without starting tmux. Save this source as
+`tmuxinator.yaml`:
+
+```yaml title="tmuxinator.yaml"
+name: imported-project
+windows:
+  - editor:
+      - printf ready
+      - printf second
+```
+
+## Preview the translation
+
+```console
+$ tmux-workspace import tmuxinator --json ./tmuxinator.yaml
+```
+
+The window's command list remains sequential commands in one pane. Use an
+explicit source `panes` list when the project needs separate panes.
+
+## Save the workspace
+
+```console
+$ tmux-workspace import tmuxinator \
+    --json \
+    --workspace-format yaml \
+    --save-to imported-tmuxinator.yaml \
+    ./tmuxinator.yaml
+```
+
+Existing destinations require `--force`. The importer rejects unexpanded ERB
+templates and unsupported lifecycle or runtime fields before writing. It does
+not evaluate Ruby. Review the translated commands and absolute directories
+before [loading](../load/) the file.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/import.md b/site/src/content/_workspace-shared/workspace/cli/import.md
index 9f24ab13..9bbea886 100644
--- a/site/src/content/_workspace-shared/workspace/cli/import.md
+++ b/site/src/content/_workspace-shared/workspace/cli/import.md
@@ -1,84 +1,65 @@
 ---
-description: Import a workspace from a supported external configuration format. Select one of the two child commands.
+description: Choose a source format and translate it into a workspace document.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp import
+  label: Import a workspace
   order: 18
 tableOfContents: true
-title: tmuxp import
+title: Import a workspace
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-Import a workspace from a supported external configuration format. Select one of
-the two child commands.
+<!-- port:py -->
+Use `tmuxp import teamocil` or `tmuxp import tmuxinator` to translate a saved
+workspace. Each child command requires a source. The parent groups the
+importers and accepts `--help`.
+
+- [Teamocil](../import-teamocil/) imports its session and window structure.
+- [tmuxinator](../import-tmuxinator/) imports its project structure.
+
+Review the converted commands and directories before loading the result.
 
-## Choose the source format
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/import_config.py).
+<!-- /port -->
 
-- [Teamocil](../import-teamocil/) converts a Teamocil workspace.
-- [tmuxinator](../import-tmuxinator/) converts a tmuxinator workspace.
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Translate a saved Teamocil or tmuxinator configuration into a native workspace
+document. Import reads and translates the file without creating tmux sessions
+or running its pane commands.
 
-The parent command groups importers and has no workspace file argument of its
-own. Each child requires a source at the parser boundary, despite
-optional-looking help. Conversion is schema translation; it does not make
-tmuxinator Ruby or ERB evaluation available in a native YAML reader.
+- [Teamocil](../import-teamocil/) translates a session with named windows and panes.
+- [tmuxinator](../import-tmuxinator/) translates a project with ordered windows.
 
-<!-- port:dotnet -->## Native .NET imports
-<!-- /port --><!-- port:cxx -->## Native C++ imports
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->The local `tmux-workspace import` commands translate YAML or JSON and validate
-the result with the native workspace loader before printing or saving it.
-Invalid shapes, conflicting non-null aliases and unsupported non-null fields
-fail before a destination is written, including when `--force` is present.
-Successful translation does not run pane commands or establish that their
-applications and directories are available.
-<!-- /port --><!-- port:cxx -->The local `tmux-workspace` command previews with `--json` and saves with an
-explicit destination. Both source and translated workspace are validated
-before a destination is replaced:
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->Without `--save-to`, `--json` returns the document and `--ndjson` returns a
-result record containing it; neither mode guesses an output filename.
-`--save-to` selects a destination, `--workspace-format` selects YAML or JSON,
-and `--force` permits replacement. Saving publishes through a temporary file
-in the destination directory. See [output](../../reference/output/).
-<!-- /port --><!-- port:cxx -->```console
-$ tmux-workspace import teamocil \
-    --save-to team.json \
-    team.yml
+```console
+$ tmux-workspace import --help
 ```
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->A missing session name uses the source filename stem. Relative project roots
-use the directory where import runs. Teamocil window roots use that same
-directory; tmuxinator window roots use the resolved project root.
-<!-- /port --><!-- port:cxx -->Use `--force` to replace an existing destination. A refused import leaves it
-intact. Unknown fields, ERB templates, host lifecycle hooks, pane titles and
-unsupported synchronization timing are reported explicitly. Imports do not
-execute Ruby.
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port --><!-- port:dotnet -->The [Teamocil](../import-teamocil/#native-net-translation) and
-[tmuxinator](../import-tmuxinator/#native-net-translation) sections describe
-command grouping, focus, synchronization and unsupported fields. Launcher
-lifecycle hooks require an explicit supported workflow; importing them as
-pane commands would change where and when they run. The importer does not
-evaluate Ruby or ERB.
 
-[Native translation source](https://github.com/libtmux/libtmux-dotnet/blob/4ac82a5b82fd8cf68d31c70a2a3eb43c587cd7c0/src/LibTmux.Workspace.Cli/ImportCommands.cs);
-[validation and saving source](https://github.com/libtmux/libtmux-dotnet/blob/4ac82a5b82fd8cf68d31c70a2a3eb43c587cd7c0/src/LibTmux.Workspace.Cli/ReadCommands.cs).
-<!-- /port --><!-- port:cxx -->See each importer for supported translations. Command text and paths should
-be reviewed before loading the result.
-<!-- /port --><!-- port:dotnet,cxx -->
-<!-- /port -->## Arguments and flags
+Select a child command and an explicit source path. Preview with `--json` before
+choosing `--save-to`. An existing destination requires `--force`.
 
-The parent accepts `-h` / `--help` and selects a child command.
+Review commands, directories and layout in the translated document before
+loading it. Source features the importer cannot preserve fail visibly. Use
+[convert](../convert/) to change YAML/JSON encoding without translating fields.
 
-All commands accept `-h` / `--help`. Root options precede the command; see the
-[CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
 <!-- /port -->
-[Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/import_config.py).
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
diff --git a/site/src/content/_workspace-shared/workspace/cli/index.md b/site/src/content/_workspace-shared/workspace/cli/index.md
index 69108a18..0871eb22 100644
--- a/site/src/content/_workspace-shared/workspace/cli/index.md
+++ b/site/src/content/_workspace-shared/workspace/cli/index.md
@@ -1,5 +1,5 @@
 ---
-description: The tmuxp command tree, root options, and native compatibility scope.
+description: Use `tmux-workspace` to load, inspect and save workspace files.
 product: workspace
 sidebar:
   group: CLI reference
@@ -9,52 +9,94 @@ tableOfContents: true
 title: Workspace command reference
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-The installed Python command is `tmuxp`. Native command names and installation
-artifacts are not established by this documentation prototype. The pages below
-<!-- port:py -->document the Python reference grammar and identify proposed native extensions.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->document the Python reference grammar and identify native extensions.
-<!-- /port -->
-## Commands
+<!-- port:py -->
+Use `tmuxp` to load, inspect and save workspace configurations. [Install
+tmuxp](../guides/installation/) separately from the core `libtmux` package.
+
+## Choose a task
 
-- [load](./load/) builds sessions from files or saved workspace names.
-- [freeze](./freeze/) captures a live session to a workspace file.
-- [convert](./convert/) changes YAML and JSON representation.
-- [edit](./edit/) opens a resolved workspace in an editor.
-- [ls](./ls/) lists discovered configurations.
-- [search](./search/) searches their names and content.
-- [debug-info](./debug-info/) reports runtime and tmux diagnostics.
-- [shell](./shell/) evaluates Python with tmux context.
-- [import](./import/) selects [Teamocil](./import-teamocil/) or [tmuxinator](./import-tmuxinator/) conversion.
+- [Load](./load/) builds a session from files or saved workspace names.
+- [Freeze](./freeze/) exports a running session.
+- [Convert](./convert/) changes YAML and JSON representation.
+- [Edit](./edit/) opens a workspace in an editor.
+- [List](./ls/) and [search](./search/) find saved configurations.
+- [Diagnostics](./debug-info/) reports runtime and tmux information.
+- [Shell](./shell/) evaluates Python with tmux context.
+- [Import](./import/) translates Teamocil or tmuxinator configuration.
 
-## Root options
+## Command options
 
-`-h` / `--help` shows help; `-V` / `--version` prints the version. `--log-level`
-selects `"debug"`, `"info"`, `warning`, `"error"`, or `critical`, with parser default
-`warning`. `--color` accepts `auto`, `always`, or `never`, defaulting to `auto`.
-Place root flags before the subcommand:
+Root options precede the subcommand:
 
 ```console
 $ tmuxp --color never ls
 ```
 
-Short flags belong to their command: `search -S` is smart case, while `load -S`
-selects a tmux socket path. Similarly, `-f` selects a tmux configuration for
-load, a field for search, and an output format for freeze.
+Short flags belong to their command: `search -S` selects smart-case matching,
+while `load -S` selects a socket path. Show the installed command options before
+using a flag:
+
+```console
+$ tmuxp load --help
+```
+
+Machine output is command-specific. Read each command reference for its
+supported formats and empty-result behavior.
+
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Use `tmux-workspace` to load, inspect and save workspace files. Complete
+[installation](../guides/installation/) and put the executable on `PATH` before
+using these commands.
+
+## Choose a task
+
+- [Load](./load/) creates a session from a workspace file.
+- [Freeze](./freeze/) captures a running session into a document.
+- [List](./ls/) and [search](./search/) find saved configurations.
+- [Edit](./edit/) opens a configuration in your editor.
+- [Convert](./convert/) changes a document between YAML and JSON.
+- [Import](./import/) translates Teamocil or tmuxinator configuration.
+- [Diagnostics](./debug-info/) reports runtime and tmux information.
+- [Completion](./completion/) configures your shell.
 
-## Machine mode and automation
+Show the options accepted by the installed command:
 
-Current Python machine output exists on `ls`, `search`, and `debug-info` as
-<!-- port:py -->described by their own flags. The proposed native command tree adds `--json` and
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->described by their own flags. The native command tree adds `--json` and
-<!-- /port -->`--ndjson` to every leaf and allows these long options before or after the
-command. These additions are not installed Python features.
+```console
+$ tmux-workspace load --help
+```
+
+## Machine output
 
-Read [output and color](../reference/output/), [exit
-behavior](../reference/exit-codes/), [completion](./completion/), and
-[automation](../guides/automation/) before building a script around a command.
+`--json` requests one JSON result. `--ndjson` requests a stream of records and
+takes precedence when both are present. Select detached loading with `-d` when
+automating session creation. Check the exit status as well as the result; a
+failed load can leave completed tmux operations in place.
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+The [output reference](../reference/output/) describes the result records, and
+[automation](../guides/automation/) covers scripts.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/load.md b/site/src/content/_workspace-shared/workspace/cli/load.md
index 8f71eb78..904ce655 100644
--- a/site/src/content/_workspace-shared/workspace/cli/load.md
+++ b/site/src/content/_workspace-shared/workspace/cli/load.md
@@ -1,87 +1,18 @@
 ---
-description: Load a workspace file, saved workspace name, or project directory. Multiple inputs build in order; without `-d`, the final session is attached or selected through the current-client flow.
+description: Create or reuse a session from a workspace file, with explicit attachment and output choices.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp load
+  label: Load a workspace
   order: 10
 tableOfContents: true
-title: tmuxp load
+title: Load a workspace
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port --><!-- port:cxx,swift -->
-<!-- /port --><!-- port:cxx -->The local C++ `tmux-workspace load` supports foreground attachment, detached
-loading and explicit append. Native `before_script` runs direct argv before
-settings and windows; all inputs are validated first. Script failure removes a
-newly owned session and preserves a borrowed append session. NDJSON streams
-bounded script output.
-<!-- /port --><!-- port:swift -->The local Swift `tmux-workspace load` attaches from a foreground terminal and
-offers switch, detached, append or cancel choices inside tmux. `-y` skips the
-mode prompt but refuses an ambiguous client selection. Redirected and machine
-calls require `-d` or `--append`. Inputs are validated before prompting, and
-detaching or interrupting the client preserves the loaded workspaces.
-
-Clients using independent `active-pane` focus on the invoking pane's physical
-window prevent native switching. The `n` (detached) and `a` (append) choices
-remain available; such clients on other windows do not block switching. If the
-selected client gains `active-pane` before handoff, switching fails and the
-loaded workspace is preserved.
-<!-- /port -->
+<!-- port:py -->
 Load a workspace file, saved workspace name, or project directory. Multiple
 inputs build in order; without `-d`, the final session is attached or selected
 through the current-client flow.
-<!-- port:rs,go,dotnet,cxx -->
-<!-- /port --><!-- port:rs -->The local Rust `tmux-workspace load --append` validates the inherited daemon
-before Python lookup and retains the borrowed session across inputs. It rejects
-missing or replaced targets. Native `-8` and `--88-colors` requests fail before
-reading workspace files; use `-2` for 256 colors. See
-[local coverage](../../reference/compatibility/) for the remaining gaps.
-<!-- /port --><!-- port:dotnet -->The native .NET CLI's `--append` authenticates the inherited daemon and retains
-one session across all inputs. It uses the current pane's session as resolved
-by tmux; moving the pane later does not change that destination. Later commands
-reject a replacement daemon, including global options after a startup script.
-Append with Python plugins or custom builders fails before building any input
-or starting Python. Use `-d` to load those extensions into a separate session.
-<!-- /port --><!-- port:cxx -->## Native C++ loading
-<!-- /port --><!-- port:rs,dotnet,cxx -->
-<!-- /port --><!-- port:rs -->See [native Rust load reporting](../../reference/output/#native-rust-load-reporting)
-for retained effects and child exit status when result output fails.
-<!-- /port --><!-- port:cxx -->Human load requires a foreground controlling terminal before mutation. Outside
-tmux it attaches to the final input's session, including a reused session.
-Inside tmux it switches the unique terminal client viewing the invoking pane;
-zero or multiple matching clients require `-d`. Machine load requires `-d` or
-`--append`; `-d` takes precedence when both are supplied.
-<!-- /port --><!-- port:rs,cxx -->
-<!-- /port --><!-- port:rs -->Native load can append [filtered JSON logs](../../reference/output/#native-rust-logging)
-with `--log-file`; `--log-level` selects optional records.
-<!-- /port --><!-- port:go -->The local Go CLI's `load --append` authenticates the inherited server and
-retains one destination session for all inputs. Moving the invoking pane during
-a script does not change that destination. Python extension append uses the
-same retained target and rejects documents with a `before_script` key. See
-[compatibility status](../../reference/compatibility/) for the execution limits.
-<!-- /port --><!-- port:dotnet -->Native load creates panes in configuration order, including windows with
-three or more panes. `pane-base-index` changes the first index, and explicit
-focus selects the configured pane without reordering it. See
-[pane configuration](../../configuration/panes/).
-<!-- /port --><!-- port:cxx -->The CLI cannot identify independent `active-pane` focus. If a terminal client
-uses it on the invoking physical window, including a linked window, use `-d`
-or `--append`. Clients on other physical windows do not block switching. The
-check repeats before handoff; enabling the flag during a script preserves
-loaded changes and prevents switching.
-
-Load publishes and flushes both streams before handing over the terminal.
-Handoff failure preserves loaded changes and reports the completed summary
-when possible. The client is checked again before switching; tmux's subsequent
-name-targeted operation still has a race. If all three standard streams are
-redirected, use `-d`: attachment needs a stream identifying the concrete
-controlling tty. See [output](../../reference/output/#native-c-load-output)
-for publication failures. `--log-file PATH` appends JSON diagnostics; see
-[native logging](../../reference/output/#native-c-logging) for levels and file
-failure behavior.
-<!-- /port -->
 ## Loading and attachment
 
 Create [`workspace.yaml`](../../guides/installation/#create-the-input) using the [installation
@@ -90,12 +21,10 @@ dedicated socket:
 
 ```console
 $ tmuxp load \
-<!-- port:py -->    -L workspace-guide \
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->    -S "$WORKSPACE_TMP/tmux.sock" \
-<!-- /port -->    -d \
-<!-- port:py -->    workspace.yaml
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->    "$WORKSPACE_TMP/workspace.yaml"
-<!-- /port -->```
+    -L workspace-guide \
+    -d \
+    workspace.yaml
+```
 
 `-d` avoids attachment. Inside an existing tmux client, the normal interactive
 flow can switch to the new session, append windows, or stay detached. `--append`
@@ -110,43 +39,7 @@ are loaded. tmuxp parses `-2` and `-8` as mutually exclusive flags,
 separate from the CLI text's `--color` setting. Legacy `-8` is unsupported;
 [tmux removed 88-color support](https://raw.githubusercontent.com/tmux/tmux/3.2a/CHANGES).
 
-<!-- port:go -->The native Go CLI supports `--log-level` and structured `--log-file` output
-on Unix. It checks the log destination before Python or tmux starts. A later
-logging failure preserves the workspace outcome; `script-output` records use
-`debug`. See the [logging contract](../../reference/output/#native-go-logging).
-<!-- /port --><!-- port:dotnet -->The native .NET command rejects `-8` and `--88-colors` before reading workspace
-files or running tmux or Python. On Linux x64, `load --log-file PATH` appends
-structured logs. Select `--log-level info` for lifecycle records or `debug` to
-include script output. The [output reference](../../reference/output/)
-describes destination validation and failure handling.
-
-## Native .NET attachment
-
-Human load requires a foreground controlling terminal on Linux x64 for
-attachment. Inside tmux, choose `y` to switch a client, `n` to load detached,
-or `a` to append. `-y` refuses an ambiguous client choice. A client using
-independent `active-pane` focus on the invoking window prevents handoff;
-detached and append modes remain available.
-
-The CLI authenticates the invoking pane and daemon before building, flushes
-output, and checks the selected client again before handoff. Late failures
-print recorded load results on stderr. SIGINT and SIGTERM report cancellation;
-a completed load can remain present after interruption during attachment.
-A client name can still be reused after the final client observation.
-
-Attached Python extension handoff remains unavailable. Use `-d` or choose `n`
-to run those extensions detached. See the
-[native handoff source](https://github.com/libtmux/libtmux-dotnet/blob/4ac82a5b82fd8cf68d31c70a2a3eb43c587cd7c0/src/LibTmux.Workspace.Cli/LoadHandoff.cs).
-<!-- /port --><!-- port:go,dotnet -->
-<!-- /port -->## Progress and script output
-<!-- port:dotnet -->
-Native .NET load implements the presets and named tokens below on a stderr
-terminal with verified geometry on Linux x64. Templates treat bare names as
-tokens and `{{`/`}}` as literal braces; unknown fields, conversions and format
-specifiers remain literal. Explicit format and line-count flags override their
-environment defaults. Disabled drawing does not validate unused progress
-environment values.
-<!-- /port -->
+## Progress and script output
 `--progress-format` accepts `default`, `minimal`, `"window"`, `"pane"`, `verbose`,
 or a custom format. Available tokens include `{session}`, `{window}`,
 `{window_index}`, `{window_total}`, `{window_progress}`,
@@ -155,36 +48,12 @@ or a custom format. Available tokens include `{session}`, `{window}`,
 `{session_pane_progress}`, `{overall_percent}`, `{bar}`, `{pane_bar}`,
 `{window_bar}`, and `{status_icon}`.
 
-<!-- port:py,ts,rs,go,java,cxx -->The output panel defaults to three lines. `--progress-lines 0` hides the panel
-<!-- /port --><!-- port:dotnet -->The tmuxp output panel defaults to three lines. `--progress-lines 0` hides the panel
-<!-- /port --><!-- port:py,ts,rs,go,java,dotnet,cxx -->and sends script output to stdout; `-1` permits all available lines up to
-<!-- /port --><!-- port:swift -->The Python reference panel defaults to three lines. `--progress-lines 0` hides
-the panel and sends script output to stdout; `-1` permits all available lines up to
-<!-- /port -->terminal height. `--no-progress` disables animation. See [environment
+The output panel defaults to three lines. `--progress-lines 0` hides the panel
+and sends script output to stdout; `-1` permits all available lines up to
+terminal height. `--no-progress` disables animation. See [environment
 settings](../../configuration/environment/) for environment bindings and
 [command ordering](../../configuration/commands/) for what is executed.
-<!-- port:py,ts,rs,dotnet,swift -->
-<!-- /port --><!-- port:ts -->The local TypeScript CLI uses an optional Python bridge for explicit plugins or
-custom builders. Extension progress shows the workspace label and script output
-without native pane counters. See [hooks and builders](../../configuration/hooks/)
-for runtime requirements and append restrictions, and [output](../../reference/output/)
-for observed effects.
-<!-- /port --><!-- port:dotnet -->The native panel also defaults to three lines, but `--progress-lines 0`
-preserves each decoded script stream's original destination. Native pane
-counters advance after command delivery and configured delays; they do not
-measure shell command completion. Python extensions show a generic activity
-label. `--no-progress`, `TMUXP_PROGRESS=0`, `TERM=dumb`, machine output and
-redirected stderr disable drawing. `NO_COLOR` removes styling while keeping
-updates. On resize, drawing stops, the old frame remains and raw output resumes.
-<!-- /port --><!-- port:swift -->Native Swift also defaults to three panel lines. Hiding its panel preserves
-each bootstrap stream's original destination. The panel updates while the
-script runs, retains at most 65,536 UTF-8 bytes and uses the initial terminal
-size without tracking resize events. JSON and NDJSON disable the panel and send
-live bootstrap chunks as structured stderr warnings. Cancellation clears the
-panel and attempts bounded final output; see the
-[child output contract](../../reference/output/#native-swift-child-output).
-<!-- /port --><!-- port:ts,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Arguments and flags
+## Arguments and flags
 
 | Argument or flags | Arity / default | Choices or meaning |
 | --- | --- | --- |
@@ -205,9 +74,79 @@ panel and attempts bounded final output; see the
 
 All commands accept `-h` / `--help`. Root options precede the command; see the
 [CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
-<!-- /port -->
+describes the formats supported by each command.
 [Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/load.py).
 
 [tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Load a saved configuration into tmux. Use `-d` for scripts so the command returns
+after construction without attaching a terminal. Command delivery does not mean
+the programs running in those panes have finished or become ready.
+
+## Load without attaching
+
+Continue the [installation walkthrough](../../guides/installation/) with its
+`workspace.yaml` and private socket:
+
+```console
+$ tmux-workspace load \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    -f /dev/null \
+    -d \
+    --json \
+    workspace.yaml
+```
+
+`-S` selects the socket path; `-L` selects a socket name. `-f` supplies tmux's
+configuration when starting a server. Keep the same endpoint for later capture,
+inspection and cleanup. Pass `-s another-name` to override the final input's
+session name.
+
+## Existing sessions and append
+
+A session with the requested name is reused. Loading is not a reconciliation
+operation that removes extra windows. Inspect a failed result before retrying:
+earlier inputs and changes to a borrowed session can remain.
+
+Inside tmux, `--append` adds windows to the invoking pane's session. It needs
+valid `TMUX` and `TMUX_PANE` values for the selected daemon. Use `-d` when loading
+onto a different server. Multiple inputs are processed in their supplied order.
+
+## Attachment and output
+
+Human loading can attach a terminal or switch a tmux client. For automation,
+choose `-d` or an authenticated append explicitly; machine output does not
+answer interactive questions. `--yes` accepts supported confirmations.
+
+`--json` returns a result; `--ndjson` emits records as work proceeds. Read
+[output](../../reference/output/) and [errors](../../reference/exit-codes/)
+before consuming those records. `--no-progress` disables the terminal display;
+it does not disable errors. `-2` requests 256-color handling from tmux.
+
+Use [configuration](../../configuration/) for fields and
+[hooks](../../configuration/hooks/) for bootstrap scripts and extensions.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/ls.md b/site/src/content/_workspace-shared/workspace/cli/ls.md
index 9076085c..12c14ceb 100644
--- a/site/src/content/_workspace-shared/workspace/cli/ls.md
+++ b/site/src/content/_workspace-shared/workspace/cli/ls.md
@@ -1,51 +1,80 @@
 ---
-description: List discovered project and saved workspace files, with optional grouping and configuration content.
+description: List the workspace files found in project and global configuration locations.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp ls
+  label: List saved workspaces
   order: 15
 tableOfContents: true
-title: tmuxp ls
+title: List saved workspaces
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 List discovered project and saved workspace files, with optional grouping and
 configuration content.
 
-## List workspace records
+## List records
 
 ```console
 $ tmuxp ls --json
 ```
 
-JSON output is an object with `workspaces` and `global_workspace_dirs`; no
-workspaces still produces the object with an empty array. `--ndjson` emits one
-workspace record per line and emits zero lines for no records. When both format
-flags are supplied, NDJSON wins. `--full` includes full configuration content.
-`--tree` groups the human display by directory.
+JSON output is an object with `workspaces` and `global_workspace_dirs`. No
+workspaces produces an empty `workspaces` array. `--ndjson` emits one record per
+line and zero lines for an empty result; it takes precedence when both output
+flags are present.
 
-Discovery includes nearest project configurations and configured global
-directories. It is not a recursive scan of every descendant directory. See
-[discovery rules](../../guides/discovery/) for precedence and candidate names.
+`--full` includes configuration content. `--tree` groups human output by
+directory. [Discovery](../../guides/discovery/) explains the locations searched.
 
-## Arguments and flags
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/ls.py).
+<!-- /port -->
 
-| Argument or flags | Arity / default | Choices or meaning |
-| --- | --- | --- |
-| `--tree` | flag; False | display workspaces grouped by directory |
-| `--json` | flag; False | output as JSON |
-| `--ndjson` | flag; False | output as NDJSON (one JSON per line) |
-| `--full` | flag; False | include full config content in output |
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+List the workspace files found in project and global configuration locations.
+Listing does not load sessions or run pane commands.
 
-All commands accept `-h` / `--help`. Root options precede the command; see the
-[CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
-<!-- /port -->
-[Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/ls.py).
+## List records
+
+```console
+$ tmux-workspace ls --json
+```
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+Include each document configuration:
+
+```console
+$ tmux-workspace ls --full --json
+```
+
+For a human display grouped by directory, use `--tree`:
+
+```console
+$ tmux-workspace ls --tree
+```
+
+Machine output preserves record values and has its own structure; do not parse
+the human tree. See [discovery](../../guides/discovery/) for the locations
+searched and [output](../../reference/output/) for the result format.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/search.md b/site/src/content/_workspace-shared/workspace/cli/search.md
index 8edf782a..cb7932c5 100644
--- a/site/src/content/_workspace-shared/workspace/cli/search.md
+++ b/site/src/content/_workspace-shared/workspace/cli/search.md
@@ -1,22 +1,19 @@
 ---
-description: Search discovered workspace fields using regular expressions or literal strings. Queries combine with AND unless `--any` selects OR.
+description: Search the fields of discovered workspace documents.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp search
+  label: Search workspaces
   order: 16
 tableOfContents: true
-title: tmuxp search
+title: Search workspaces
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-Search discovered workspace fields using regular expressions or literal strings.
-Queries combine with AND unless `--any` selects OR.
+<!-- port:py -->
+Search discovered workspace fields with regular expressions or literal strings.
+Query terms combine with AND unless `--any` selects OR.
 
-## Find workspaces by session name
+## Find a session name
 
 ```console
 $ tmuxp search \
@@ -26,45 +23,70 @@ $ tmuxp search \
     workspace
 ```
 
-Field prefixes in query terms and repeated `--field` restrictions select name,
-session (`s`), path (`p`), window (`w`), or pane data. `--ignore-case` ignores
-case; `--smart-case` does so only when a pattern has no uppercase.
-`--word-regexp` requires whole words and `--invert-match` selects nonmatches.
-
-JSON results contain `"name"`, `"path"`, `"session_name"`, `"source"`, `matched_fields`,
-and `"matches"`. The pinned reference emits an empty byte stream for no matches,
-even with `--json`. With no query, machine search can print human help and
-return normally. An invalid regular expression can also yield no machine output.
-<!-- port:py -->The proposed native contract instead uses `[]` for an empty JSON result and
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->The native contract instead uses `[]` for an empty JSON result and
-<!-- /port -->usage status 2 for a missing or invalid pattern.
-
-Python regular-expression behavior is part of compatibility. Native regex
-libraries differ in lookaround, backreferences, Unicode, flags, and word
-boundaries. Matching the options alone does not establish expression
-equivalence. See [compatibility](../../reference/compatibility/) and
-[output](../../reference/output/).
-
-## Arguments and flags
-
-| Argument or flags | Arity / default | Choices or meaning |
-| --- | --- | --- |
-| `"query_terms"` | zero or more | search patterns (prefix with field: for field-scoped search) |
-| `-f`, `--field` | value; None | restrict search to field(s): name, session/s, path/p, window/w, pane |
-| `-i`, `--ignore-case` | flag; False | case-insensitive matching |
-| `-S`, `--smart-case` | flag; False | case-insensitive unless pattern has uppercase |
-| `-F`, `--fixed-strings` | flag; False | treat patterns as literal strings, not regex |
-| `-w`, `--word-regexp` | flag; False | match whole words only |
-| `-v`, `--invert-match` | flag; False | show workspaces that do NOT match |
-| `--any` | flag; False | match ANY pattern (OR logic); default is ALL (AND logic) |
-| `--json` | flag; False | output as JSON |
-| `--ndjson` | flag; False | output as NDJSON (one JSON per line) |
-
-All commands accept `-h` / `--help`. Root options precede the command; see the
-[CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
+Field prefixes and repeated `--field` restrictions select name, session (`s`),
+path (`p`), window (`w`) or pane data. `--ignore-case` ignores case;
+`--smart-case` does so only when a pattern has no uppercase. `--word-regexp`
+requires whole words and `--invert-match` selects nonmatches.
+
+## Empty and invalid queries
+
+The documented implementation emits no bytes for an empty search result,
+including with `--json`. With no query, machine search can print human help and
+return normally. An invalid regular expression can also produce no machine
+output. Account for these outcomes before parsing stdout as JSON.
+
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/search.py).
 <!-- /port -->
-[Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/search.py).
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Search the fields of discovered workspace documents. Use literal matching when
+the input should be treated as text rather than a regular expression.
+
+## Find a session name
+
+```console
+$ tmux-workspace search \
+    --json \
+    --fixed-strings \
+    --field session \
+    workspace
+```
+
+Repeat `--field` to restrict additional fields. Query terms combine with AND;
+`--any` selects OR. `--ignore-case`, `--smart-case`, `--word-regexp`, and
+`--invert-match` control matching. Inspect the installed `search --help` for
+supported field names and aliases.
+
+<!-- port:go -->
+## Regular expressions
+
+The default engine uses Go regular expressions and ASCII word boundaries. Structured pane commands are searched as JSON text. Unsupported regex syntax fails; it does not start another runtime automatically.
+
+`--regex-engine python` explicitly enables lookaround, backreferences and Unicode word boundaries through an installed Python 3.10 or newer interpreter. Ordinary searches do not need that optional runtime.
+<!-- /port -->
+
+Check both the exit status and [machine result](../../reference/output/). An
+empty successful search and a failed pattern are different outcomes.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/cli/shell.md b/site/src/content/_workspace-shared/workspace/cli/shell.md
index cb291573..2fba8857 100644
--- a/site/src/content/_workspace-shared/workspace/cli/shell.md
+++ b/site/src/content/_workspace-shared/workspace/cli/shell.md
@@ -1,140 +1,88 @@
 ---
-description: Open a Python shell with tmux objects available, or evaluate Python using `-c`. This command remains Python-specific even when reached through a native command.
+description: Use the optional Python runtime to inspect a workspace through the native command.
 product: workspace
 sidebar:
   group: CLI reference
-  label: tmuxp shell
+  label: Evaluate in a workspace
   order: 17
 tableOfContents: true
-title: tmuxp shell
-ports:
-  py:
-    description: Open a Python shell with tmux objects available, or evaluate Python using `-c`. This command remains Python-specific even when reached through a future native command.
+title: Evaluate in a workspace
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-Open a Python shell with tmux objects available, or evaluate Python using `-c`.
-<!-- port:py -->This command remains Python-specific even when reached through a future native
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->This command remains Python-specific even when reached through a native
-<!-- /port -->command.
-<!-- port:cxx,swift -->
-<!-- /port --><!-- port:cxx -->## Native execution
+<!-- port:py -->
+Open a Python shell with tmux objects available, or pass `-c` to evaluate a
+Python expression and exit.
 
-The development C++ CLI invokes an installed tmuxp 1.74.0 console executable.
-Put it on `PATH`, or set `TMUX_WORKSPACE_TMUXP` to its executable path. That
-value accepts a single path, including spaces, without interpreter arguments.
-Optional backends belong in the selected executable's Python environment.
-<!-- /port --><!-- port:swift -->## Evaluate with a selected server
-<!-- /port --><!-- port:cxx,swift -->
-Continue the [installation walkthrough](../../guides/installation/) through
-its detached load, leaving `workspace-guide` running in the same shell:
+After the [installation walkthrough](../../guides/installation/) creates its
+dedicated server:
 
 ```console
-<!-- /port --><!-- port:cxx -->$ build/cxx-dev/apps/workspace/tmux-workspace shell \
-    -S "$WORKSPACE_TMP/tmux.sock" \
-    -c 'print(pane.pane_id)' \
-    --json \
-    workspace-guide editor
+$ tmuxp shell \
+    -L workspace-guide \
+    -c 'print(server.sessions)'
 ```
 
-JSON captures runtime stdout, stderr and status under `"script_output"`.
-NDJSON emits flushed `script-output` records with `"stream"` and `"text"`,
-then a completed or failed result. Capture is limited to 1 MiB per stream;
-overflow stops the child group and reports `OUTPUT_LIMIT` with bounded output.
-Human output streams to its original destinations. The runtime's own messages
-remain part of its output.
+Optional session and window arguments select a narrower context. `--best`
+chooses an available backend; explicit backends such as `--ipython` need their
+packages installed in the same Python environment.
+
+`--use-pythonrc` and `--no-startup` control startup loading. The last occurrence
+wins. `--use-vi-mode` and `--no-vi-mode` follow the same ordering rule.
+
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/shell.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+`tmux-workspace shell` opens the optional Python inspection environment for a
+loaded session. Code passed to `-c` executes in that environment, with tmux
+objects such as `server`, `session`, `window` and `pane` available.
+
+## Runtime requirement
+
+Install tmuxp 1.74.0 in a separate Python environment and set
+`TMUX_WORKSPACE_PYTHON` to that environment's Python executable. The native CLI
+checks the runtime before evaluating code. Ordinary workspace loading does
+not require this inspection runtime.
 
-Machine calls require `-c`, including an empty code string. Interactive human
-calls require a foreground controlling terminal; exit restores its settings
-and foreground group. SIGINT and SIGTERM sent to the workspace process cancel
-its owned child group. `-S` takes precedence over `-L`, and opposing startup
-flags keep their original order. See the
-[native shell contract](https://github.com/libtmux/libtmux-cxx/blob/3963cd7792a72b2b500b8ed4ba08016a791c0d41/apps/workspace/README.md#optional-tmuxp-shell).
-<!-- /port --><!-- port:py,ts,rs,go,java,dotnet,cxx -->
 ## Evaluate with a selected server
 
-<!-- /port --><!-- port:py,cxx -->After the [installation walkthrough](../../guides/installation/) starts its
-dedicated server:
-<!-- /port --><!-- port:ts,rs,go,java,dotnet -->Continue the [installation walkthrough](../../guides/installation/) through
-its detached load, leaving `workspace-guide` running in the same shell:
-<!-- /port --><!-- port:py,ts,rs,go,java,dotnet,cxx -->
+Continue the [installation walkthrough](../../guides/installation/) through its
+detached load. Select its socket, session and window:
+
 ```console
-<!-- /port -->$ tmuxp shell \
-<!-- port:py -->    -L workspace-guide \
-    -c 'print(server.sessions)'
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->    -S "$WORKSPACE_TMP/tmux.sock" \
-    -c 'print(server.sessions)' \
+$ tmux-workspace shell \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    -c 'print(pane.pane_id)' \
+    --json \
     workspace-guide editor
-<!-- /port -->```
+```
 
-Use `-c`; the reference does not define `--command`. Optional session and window
-arguments select context. `--best` chooses the best available shell backend; the
-explicit selectors require their corresponding Python packages. The `--pdb` path
-uses a debugger rather than a normal REPL.
+The result includes captured output and child status. Check the command's exit
+status before consuming it. An interactive shell needs a terminal; use `-c`
+when stdout belongs to automation.
 
-The paired `--use-pythonrc` / `--no-startup` and `--use-vi-mode` /
-`--no-vi-mode` options share destinations. The last occurrence wins. The
-negative options disable the corresponding setting. See
-[environment](../../configuration/environment/) for startup and backend
-settings.
+`shell --help` lists backend and startup choices. Optional shell backends must
+be installed in the selected Python environment.
 
-A native REPL is not an equivalent implementation of Python `-c`, IPython, or
-<!-- port:py -->PTPython. The compatibility proposal uses an optional version-checked Python
-bridge and reports an unsupported-runtime error if it is absent. Interactive
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->PTPython. Native ports that support this command use an optional version-checked
-Python bridge and report an unsupported-runtime error if it is absent. Check
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,swift -->[port coverage](../../reference/compatibility/) before relying on that bridge. Interactive
-<!-- /port --><!-- port:py,ts,rs,go,java,dotnet,swift -->machine output needs a separate terminal; an interactive transcript cannot share
-JSON stdout.
-<!-- /port --><!-- port:cxx -->[port coverage](../../reference/compatibility/) before relying on that bridge.
-The C++ command requires `-c` for machine output.
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
 <!-- /port -->
-Backend selectors are mutually exclusive.
 <!-- port:swift -->
-## Native Swift shell
-
-The Swift command uses `TMUX_WORKSPACE_PYTHON` (default `python3`) and checks
-for tmuxp 1.74.0 plus libtmux `Server` support for selecting `tmux_bin` before
-evaluation. It passes the selected native tmux executable and socket to that
-runtime. Run the example above with `tmux-workspace` after installing this
-compatible Python environment.
-
-Captured `-c` calls stream output while Python runs. Machine calls require
-`-c`; live chunks use structured stderr warnings and the final stdout result
-contains both captured streams and the child exit status. See the
-[child output contract](../../reference/output/#native-swift-child-output)
-for filtering, UTF-8 handling and the one MiB limit per stream. Interactive
-backends require a terminal; optional backend packages need broader verification.
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
 <!-- /port -->
-## Arguments and flags
-
-| Argument or flags | Arity / default | Choices or meaning |
-| --- | --- | --- |
-| `"session_name"` | optional |  |
-| `"window_name"` | optional |  |
-| `-S` | value; None | pass-through for tmux -S |
-| `-L` | value; None | pass-through for tmux -L |
-| `-c` | value; None | instead of opening shell, execute python code in libtmux and exit |
-| `--best` | flag; best | use best shell available in site packages |
-| `--pdb` | flag; None | use plain pdb |
-| `--code` | flag; None | use stdlib's code.interact() |
-| `--ptipython` | flag; None | use ptpython + ipython |
-| `--ptpython` | flag; None | use ptpython |
-| `--ipython` | flag; None | use ipython |
-| `--bpython` | flag; None | use bpython |
-| `--use-pythonrc` | flag; False | load PYTHONSTARTUP env var and ~/.pythonrc.py script in --code |
-| `--no-startup` | flag; False | disable Python startup loading; shares a destination with `--use-pythonrc`, last occurrence wins |
-| `--use-vi-mode` | flag; False | use vi-mode in ptpython/ptipython |
-| `--no-vi-mode` | flag; False | disable vi mode; shares a destination with `--use-vi-mode`, last occurrence wins |
-
-All commands accept `-h` / `--help`. Root options precede the command; see the
-[CLI overview](../). The [output reference](../../reference/output/)
-<!-- port:py -->distinguishes current Python flags from proposed all-command JSON and NDJSON.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->distinguishes current Python flags from native all-command JSON and NDJSON.
 <!-- /port -->
-[Parser and implementation source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/shell.py).
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
diff --git a/site/src/content/_workspace-shared/workspace/configuration/commands.md b/site/src/content/_workspace-shared/workspace/configuration/commands.md
index efd2ebd5..e77f13be 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/commands.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/commands.md
@@ -1,33 +1,15 @@
 ---
-description: Tmuxp workspace commands, field meanings, defaults, and execution behavior.
+description: Order pane setup and command delivery, Enter handling and delays.
 product: workspace
 sidebar:
   group: Configuration
-  label: Commands
+  label: Workspace commands
   order: 34
 tableOfContents: true
 title: Workspace commands
-ports:
-  ts:
-    description: Tmuxp workspace commands and current TypeScript builder compatibility.
-  rs:
-    description: Tmuxp workspace commands and current Rust builder compatibility.
-  go:
-    description: Tmuxp workspace commands and current Go builder compatibility.
-  java:
-    description: Tmuxp workspace commands and current Java builder compatibility.
-  dotnet:
-    description: Tmuxp workspace commands and current .NET builder compatibility.
-  cxx:
-    description: Tmuxp workspace commands and current C++ builder compatibility.
-  swift:
-    description: Tmuxp workspace commands and current Swift builder compatibility.
 ---
 
-<!-- port:py -->This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Tmuxp sends workspace commands into panes in order. A command can be a string or
 a mapping with `"cmd"` and execution controls. `shell_command_before` adds shared
 setup without copying it into every pane.
@@ -103,53 +85,93 @@ checks its exit status. Use it for bootstrap work that must succeed before
 configured windows are built, rather than treating pane command delivery as a
 checked process result.
 
-<!-- port:ts -->## Current TypeScript builder
-<!-- /port --><!-- port:rs -->## Current Rust builder
-<!-- /port --><!-- port:go -->## Current Go builder
-<!-- /port --><!-- port:java -->## Native Java CLI
-<!-- /port --><!-- port:dotnet -->## Current .NET builder
-<!-- /port --><!-- port:cxx -->## Current C++ builder
-<!-- /port --><!-- port:swift -->## Current Swift builder
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts -->The default native policy sends commands only to newly created panes. `commands:
-"always"` also replays commands in reused panes. These library options are not
-tmuxp YAML keys.
-<!-- /port --><!-- port:rs -->The native model is narrower than the command dictionaries and normalization
-described here. Do not assume enter/delay overrides or tmuxp expansion follow
-from accepting a YAML mapping.
-<!-- /port --><!-- port:go -->Command dictionaries support enter and delays in seconds. Tmuxp interpolation is
-absent. Verify override carry behavior against the reference before using a
-timing-sensitive configuration.
-<!-- /port --><!-- port:java -->The local CLI supports command strings, lists and `{cmd, enter, sleep_before,
-sleep_after}` objects. Enter and delay defaults carry forward until an explicit
-override. Before commands accumulate in session/window/pane order, and history
-suppression prefixes delivered commands with a space. Command variables remain
-for the pane shell to expand; this differs from tmuxp's invoking-process
-expansion. [Readiness policy](../../reference/compatibility/) is separate from
-command completion.
-<!-- /port --><!-- port:dotnet -->The package supports scalar or ordered shell command strings. Its readiness
-policy concerns prompt detection; it does not add the reference command
-dictionary timing and override semantics.
-<!-- /port --><!-- port:cxx -->Command metadata supports enter, delays, and suppression. The consumer creates
-topology before delivering commands; it does not perform the complete tmuxp
-normalization pipeline.
-<!-- /port --><!-- port:swift -->Swift commands carry command text and Enter behavior. The reference delay
-dictionaries, inherited before commands, history suppression, and variable
-expansion are not supplied by that model.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->See the [native builder behavior](../../internals/topics/) and [configuration
-<!-- /port --><!-- port:ts -->source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-<!-- /port --><!-- port:rs -->source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-<!-- /port --><!-- port:go -->source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-<!-- /port --><!-- port:dotnet -->source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-<!-- /port --><!-- port:cxx -->source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-<!-- /port --><!-- port:swift -->source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->before using these fields through application code.
-<!-- /port --><!-- port:java -->See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../../internals/topics/). Its schema is not the CLI configuration
-contract.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Reference source
+## Reference source
 
 [loader.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/loader.py); [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [sleep.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/sleep.yaml); [skip-send.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/skip-send.yaml).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+`shell_command_before` adds setup for every affected pane. Setup is ordered from
+session to window to pane, followed by that pane's `shell_command` entries.
+
+```yaml title="commands.yaml"
+session_name: commands-example
+shell_command_before:
+  - printf session-setup
+windows:
+  - window_name: shell
+    shell_command_before:
+      - printf window-setup
+    panes:
+      - shell_command_before:
+          - printf pane-setup
+<!-- port:swift -->
+        sleep_after: 0.01
+<!-- /port -->
+        shell_command:
+          - cmd: printf ready
+<!-- port:ts,rs,go,java,dotnet,cxx -->
+            sleep_after: 0.01
+<!-- /port -->
+          - cmd: printf waiting
+            enter: false
+<!-- port:ts,rs,go,java,dotnet,cxx -->
+            sleep_after: 0
+<!-- /port -->
+```
+
+The final command is typed without Enter. Delays are measured in seconds and
+pause delivery; they do not verify that an application is ready or that an
+earlier shell command succeeded.
+
+## Enter and timing
+
+Pane-level `enter`, `sleep_before` and `sleep_after` establish defaults.
+
+<!-- port:ts,rs,go,java,dotnet,cxx -->
+Command mappings can change those defaults. An override carries to following
+commands in that pane until another override. Set an explicit value when later
+commands need to restore Enter or remove a delay.
+<!-- /port -->
+<!-- port:swift -->
+Command mappings can override Enter, and that override carries to following
+commands. Set delays on the pane; timing fields inside command mappings are
+refused.
+<!-- /port -->
+
+## History and readiness
+
+History suppression prefixes sent commands with a space. The shell still needs
+its own setting to ignore leading-space commands, such as Bash's
+`HISTCONTROL=ignorespace` or zsh's `HIST_IGNORE_SPACE`.
+
+Prompt readiness delays initial input while a shell draws its prompt. It is
+separate from application readiness and command completion. Use a checked
+[before script](../hooks/) for bootstrap work whose exit status must stop the
+load on failure.
+
+See [environment](../environment/) before putting variable expressions in
+commands.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/configuration/directories.md b/site/src/content/_workspace-shared/workspace/configuration/directories.md
index 158b1891..5800804d 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/directories.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/directories.md
@@ -1,33 +1,15 @@
 ---
-description: Tmuxp workspace files and directories, field meanings, defaults, and execution behavior.
+description: Resolve saved workspace files and the working directories used by panes.
 product: workspace
 sidebar:
   group: Configuration
   label: Files and directories
   order: 36
 tableOfContents: true
-title: Workspace files and directories
-ports:
-  ts:
-    description: Tmuxp workspace files and directories and current TypeScript builder compatibility.
-  rs:
-    description: Tmuxp workspace files and directories and current Rust builder compatibility.
-  go:
-    description: Tmuxp workspace files and directories and current Go builder compatibility.
-  java:
-    description: Tmuxp workspace files and directories and current Java builder compatibility.
-  dotnet:
-    description: Tmuxp workspace files and directories and current .NET builder compatibility.
-  cxx:
-    description: Tmuxp workspace files and directories and current C++ builder compatibility.
-  swift:
-    description: Tmuxp workspace files and directories and current Swift builder compatibility.
+title: Files and directories
 ---
 
-<!-- port:py -->This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Tmuxp accepts an explicit workspace file, a saved workspace name, or a project
 directory. The location of the selected file determines how config-relative
 paths expand. Use an explicit file while debugging a discovery problem.
@@ -102,15 +84,11 @@ A plain relative window directory such as src is joined to the session directory
 later, during trickle. A dot-relative pane under that still-relative window can
 resolve against the invoking process's current directory first. Use an explicit
 ./src window value as above, or an absolute path, to avoid that inconsistency.
-Native normalization that resolves every child consistently would correct this
-reference behavior.
 
 When a document names no `start_directory` at any level, panes start in the
 directory the command was run from, not the directory the workspace file lives
-in. That is what tmuxp does, and all eight implementations agree on it. An
-explicit relative value such as `./src` is the other case: it always resolves
-against the workspace file's directory, at every level, so a workspace stays
-portable no matter where it is loaded from.
+in. Use an explicit session directory and child directories as described above
+when loading a file from another working directory.
 
 Absolute and expanded-home paths retain their explicit location. Quote `~` in
 YAML to avoid its null spelling. A pane override also applies to the first pane
@@ -121,8 +99,7 @@ directory when loading a workspace from a different working directory.
 
 A nonexistent path can make tmux start somewhere unexpected, including a home
 directory, rather than producing a useful configuration error. Inspect the
-actual pane directory when verifying a workspace. Native ports may reject,
-retain, report, or pass through the value differently.
+actual pane directory when verifying a workspace.
 
 A relative before_script path is resolved from the workspace file. Its process
 working directory uses the session start_directory when supplied. A bootstrap
@@ -130,51 +107,66 @@ process can create required project files, but it runs after the initial tmux
 session exists. See [hooks](../hooks/) for failure handling and
 [environment](../environment/) for variable expansion.
 
-<!-- port:ts -->## Current TypeScript builder
-<!-- /port --><!-- port:rs -->## Current Rust builder
-<!-- /port --><!-- port:go -->## Current Go builder
-<!-- /port --><!-- port:java -->## Native Java CLI
-<!-- /port --><!-- port:dotnet -->## Current .NET builder
-<!-- /port --><!-- port:cxx -->## Current C++ builder
-<!-- /port --><!-- port:swift -->## Current Swift builder
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts -->Directories inherit from workspace to window to pane. The package does not
-implement the tmuxp name/project discovery workflow or its full config-relative
-expansion.
-<!-- /port --><!-- port:rs -->Directories inherit through native workspace/window/pane values. Config-file
-discovery and tmuxp path expansion are not supplied by the workspace library.
-<!-- /port --><!-- port:go -->`Workspace.MissingDirectories` reports absent directories before a build. The
-caller decides whether to fail or allow setup to create them. Values are not
-expanded using tmuxp environment rules.
-<!-- /port --><!-- port:java -->The local CLI supports `start_directory` at session, window and pane scope.
-Relative paths resolve from the source document's directory, then inherit
-through the session/window/pane hierarchy. Tilde and defined invoking-process
-variables expand before existing-directory checks. `before_script` uses the
-invocation directory unless the workspace sets `start_directory` explicitly.
-Imports instead record absolute invocation-based roots before saving.
-<!-- /port --><!-- port:dotnet -->Working-directory strings pass to tmux unchanged. Relative paths are not rebased
-to the workspace file. Resolve them explicitly before native execution if that
-behavior is required.
-<!-- /port --><!-- port:cxx -->The model carries directories; config discovery and all tmuxp expansion rules
-are not a CLI feature here. Open a core server handle against the intended live
-endpoint before using the consumer.
-<!-- /port --><!-- port:swift -->A window directory overrides the workspace directory; a split pane can override
-both. The first pane uses the window directory. Encoding a Workspace preserves
-model values and does not resolve or discover configuration files.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->See the [native builder behavior](../../internals/topics/) and [configuration
-<!-- /port --><!-- port:ts -->source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-<!-- /port --><!-- port:rs -->source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-<!-- /port --><!-- port:go -->source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-<!-- /port --><!-- port:dotnet -->source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-<!-- /port --><!-- port:cxx -->source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-<!-- /port --><!-- port:swift -->source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->before using these fields through application code.
-<!-- /port --><!-- port:java -->See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../../internals/topics/). Its schema is not the CLI configuration
-contract.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Reference source
+## Reference source
 
 [finders.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/finders.py); [loader.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/loader.py); [import_config.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/import_config.py); [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [start-directory.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/start-directory.yaml).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Use an explicit file path when debugging workspace discovery. A directory such
+as `.` selects a project configuration; a saved name selects a global workspace.
+See [finding workspaces](../../guides/discovery/) for that lookup order.
+
+## Set a starting directory
+
+```yaml title="directories.yaml"
+session_name: directories-example
+start_directory: ./
+windows:
+  - window_name: shell
+    start_directory: ./
+    panes:
+      - start_directory: ./
+        shell_command: pwd
+```
+
+An explicit relative session directory starts from the configuration file's
+directory. Child directories resolve through their parent configuration. Use
+absolute paths when a workspace deliberately points outside its project.
+
+Quote home shortcuts in YAML, such as `"~/src/project"`; an unquoted `~` is a
+null value. An omitted directory lets the loader and tmux use their invocation
+context. The explicit relative directory in this example selects the file's
+project context.
+
+## Verify the running pane
+
+A saved path can be absent on another machine. Inspect the real pane directory
+after loading rather than relying on successful YAML parsing. tmux can fall back
+to a home directory when a requested path does not exist.
+
+Bootstrap paths and process working directories have separate rules. See
+[before scripts](../hooks/) before using one to create directories.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/configuration/environment.md b/site/src/content/_workspace-shared/workspace/configuration/environment.md
index 4665d30f..0ea7bc2d 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/environment.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/environment.md
@@ -1,38 +1,15 @@
 ---
-title: "Workspace environment"
-description: "Tmuxp workspace environment."
+title: Workspace environment
+description: Configure the loader process and the variables available to pane commands.
 product: workspace
 sidebar:
   group: Configuration
-  label: "Environment"
+  label: Workspace environment
   order: 35
 tableOfContents: true
-ports:
-  py:
-    description: "Tmuxp workspace environment, field meanings, defaults, and execution behavior."
-  ts:
-    description: "Tmuxp workspace environment and current TypeScript builder compatibility."
-  rs:
-    description: "Tmuxp workspace environment and current Rust builder compatibility."
-  go:
-    description: "Tmuxp workspace environment and current Go builder compatibility."
-  java:
-    description: "Tmuxp workspace environment and current Java builder compatibility."
-  dotnet:
-    description: "Tmuxp workspace environment and current .NET builder compatibility."
-  cxx:
-    description: "Tmuxp workspace environment and current C++ builder compatibility."
-  swift:
-    description: "Tmuxp workspace environment and current Swift builder compatibility."
 ---
-<!-- port:py -->
-This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port -->
-<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
 
+<!-- port:py -->
 The environment of the process running tmuxp controls discovery, expansion, and
 presentation. A workspace's `"environment"` mapping controls the tmux session or
 the environment passed when launching a pane. These are separate settings.
@@ -96,104 +73,88 @@ general template language.
 
 Explicit progress flags take precedence over their corresponding defaults.
 Nonempty NO_COLOR disables color even with always; otherwise explicit
-never/always precede FORCE_COLOR and automatic TTY detection. Machine-output
-extensions must disable ANSI regardless of forced color.
-
-`CLICOLOR` and `CLICOLOR_FORCE` are proposed cross-port presentation extensions,
-not variables read by this tmuxp reference. Native format codecs also need
-separate evidence before claiming the Python separator override works.
+never/always precede FORCE_COLOR and automatic TTY detection. Use supported machine formats when consuming output in a script.
 
 See [directories](../directories/) for existing-directory precedence,
 [layouts](../layouts/) for size resolution, and [shell](../../cli/shell/) for
 Python-specific environment effects.
-<!-- port:ts -->
-
-## Current TypeScript builder
 
-The strict schema does not implement tmuxp environment maps or full
-interpolation. Node support in the package does not supply Bun's YAML parser.
+## Reference source
 
-See the [native builder behavior](../../internals/topics/) and [configuration
-source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-before using these fields through application code.
+[loader.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/loader.py); [finders.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/finders.py); [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [load.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/load.py); [shell.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/shell.py); [shell.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/shell.py); [colors.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/_internal/colors.py); [util.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/util.py).
 <!-- /port -->
-<!-- port:rs -->
-
-## Current Rust builder
 
-Environment maps are present in the model. Variable interpolation and tmuxp
-pane/window environment selection are separate execution requirements and must
-not be inferred from those fields.
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+The CLI's process environment controls discovery and optional runtimes.
+Configuration `environment` maps provide variables to the workspace's shells.
 
-See the [native builder behavior](../../internals/topics/) and [configuration
-source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-before using these fields through application code.
-<!-- /port -->
-<!-- port:go -->
+```yaml title="environment.yaml"
+session_name: environment-example
+environment:
+  DOC_SESSION: session
+windows:
+  - window_name: shell
+    environment:
+      DOC_WINDOW: window
+    panes:
+      - environment:
+          DOC_PANE: pane
+        shell_command: 'printf "ENV=%s|%s|%s\n" "$DOC_SESSION" "$DOC_WINDOW" "$DOC_PANE"'
+      - shell_command: 'printf "ENV=%s|%s|%s\n" "$DOC_SESSION" "$DOC_WINDOW" "$DOC_PANE"'
+```
 
-## Current Go builder
+A pane map selects its launch environment in place of the window map. Session
+variables still apply. Repeat a window variable in the pane map when that pane
+needs it too. Avoid putting credentials in example files or diagnostic output.
 
-Go writes environment entries from every level to the session. The last
-assignment remains visible to later processes. This differs from the reference
-per-pane launch environment and can expose a pane value to later panes.
+## Variable expressions
 
-See the [native builder behavior](../../internals/topics/) and [configuration
-source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-before using these fields through application code.
+<!-- port:rs -->
+Names, directories, options and environment values expand defined variables
+from the loader process. Command and launch-shell text keep their expressions
+for the pane shell; referenced loader variables are supplied to that pane unless
+the document already sets them. Shell quoting therefore remains meaningful.
 <!-- /port -->
-<!-- port:java -->
+<!-- port:ts,go,java,dotnet,cxx,swift -->
+The loader expands defined variables in configuration values before delivery.
+An expression can therefore use the invoking process's value before the pane
+shell reads it. Use explicit configuration variables and inspect resulting
+commands when moving a workspace between environments.
+<!-- /port -->
+
+## Loader settings
 
-## Native Java CLI
+| Variable | Use |
+| --- | --- |
+| `TMUXP_CONFIGDIR` | Preferred existing directory for saved workspaces |
+| `XDG_CONFIG_HOME` | Base for the `tmuxp` configuration directory |
+| `EDITOR` | Editor used by `edit` |
+| `TMUX_WORKSPACE_PYTHON` | Optional interpreter for `shell` and supported extensions |
+| `NO_COLOR` | Disable terminal color when nonempty |
 
-The local CLI accepts session environment and window/pane launch maps. Window
-environment applies when a pane has no map; a pane map replaces it. Names,
-directories, environment values and option strings expand tilde and defined
-invoking-process variables. Shell command text retains variables for the pane
-shell. Session-local environment is currently omitted by native capture; a
-whole-session environment round trip is not claimed.
+These are process settings, not workspace YAML keys. Read
+[discovery](../../guides/discovery/), [editing](../../cli/edit/) and
+[shell inspection](../../cli/shell/) for their task-specific behavior.
 
-See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../../internals/topics/). Its schema is not the CLI configuration
-contract.
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
 <!-- /port -->
 <!-- port:dotnet -->
-
-## Current .NET builder
-
-The configuration subset does not implement the full session/window/pane
-environment and variable expansion described here. The CLI progress/color
-variables are reference behavior, not .NET builder settings.
-
-See the [native builder behavior](../../internals/topics/) and [configuration
-source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-before using these fields through application code.
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
 <!-- /port -->
 <!-- port:cxx -->
-
-## Current C++ builder
-
-The parser accepts supported environment values, but tmuxp expansion and
-pane/window selection must be checked against native execution. Core format
-separator behavior is a codec concern, not a workspace print option.
-
-See the [native builder behavior](../../internals/topics/) and [configuration
-source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-before using these fields through application code.
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
 <!-- /port -->
 <!-- port:swift -->
-
-## Current Swift builder
-
-Tmuxp environment expansion and session/window/pane environment maps are outside
-the current Swift model. YAML support itself requires opting in to the
-YAMLWorkspaces trait.
-
-See the [native builder behavior](../../internals/topics/) and [configuration
-source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-before using these fields through application code.
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
 <!-- /port -->
-
-## Reference source
-
-[loader.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/loader.py); [finders.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/finders.py); [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [load.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/load.py); [shell.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/shell.py); [shell.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/shell.py); [colors.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/_internal/colors.py); [util.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/util.py).
diff --git a/site/src/content/_workspace-shared/workspace/configuration/hooks.md b/site/src/content/_workspace-shared/workspace/configuration/hooks.md
index 9590754c..69ecdea4 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/hooks.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/hooks.md
@@ -1,40 +1,15 @@
 ---
-description: Tmuxp workspace hooks and builders, field meanings, defaults, and execution behavior.
+description: Run a checked bootstrap process before workspace commands.
 product: workspace
 sidebar:
   group: Configuration
-  label: Hooks and builders
+  label: Bootstrap scripts and extensions
   order: 38
 tableOfContents: true
-title: Workspace hooks and builders
-ports:
-  ts:
-    description: Tmuxp workspace hooks and builders and current TypeScript builder compatibility.
-  rs:
-    description: Tmuxp workspace hooks and builders and current Rust builder compatibility.
-  go:
-    description: Tmuxp workspace hooks and builders and current Go builder compatibility.
-  java:
-    description: Tmuxp workspace hooks and builders and current Java builder compatibility.
-  dotnet:
-    description: Tmuxp workspace hooks and builders and current .NET builder compatibility.
-  cxx:
-    description: Tmuxp workspace hooks and builders and current C++ builder compatibility.
-  swift:
-    description: Tmuxp workspace hooks and builders and current Swift builder compatibility.
+title: Bootstrap scripts and extensions
 ---
 
-<!-- port:py -->This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port --><!-- port:dotnet -->
-The local .NET CLI supports native before scripts and a checked Python bridge
-for plugins and custom builders. Append with Python extensions is unavailable:
-it fails before building any input or starting Python. Use `-d` to load those
-extensions into a separate session. Empty `plugins: []` and a null
-`workspace_builder` use native loading. The library builder has the separate
-limits described [below](#current-net-builder).
-<!-- /port -->
+<!-- port:py -->
 Workspace scripts, plugins, and custom builders extend how Python tmuxp creates
 a session. They are execution features, not passive configuration metadata. A
 workspace naming Python code needs that code installed or importable in tmuxp's
@@ -126,77 +101,82 @@ a shell prompt, not the eventual application's health, and do not acknowledge
 that every later command was consumed. Use [commands](../commands/) for explicit
 delays and Enter behavior.
 
-<!-- port:ts -->## Current TypeScript builder
-<!-- /port --><!-- port:rs -->## Current Rust builder
-<!-- /port --><!-- port:go -->## Current Go builder
-<!-- /port --><!-- port:java -->## Native Java CLI
-<!-- /port --><!-- port:dotnet -->## Current .NET builder
-<!-- /port --><!-- port:cxx -->## Current C++ builder
-<!-- /port --><!-- port:swift -->## Current Swift builder
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts -->The local `tmux-workspace load` CLI runs ordinary workspaces without Python.
-Explicit `plugins` or `workspace_builder` selections use an interpreter with
-tmuxp 1.74.0 installed. `TMUX_WORKSPACE_PYTHON` selects it; the default is
-`python3`. Empty plugin lists and blank builder names stay native.
-<!-- /port --><!-- port:go -->The library package rejects `before_script` and Python plugins. The local
-`tmux-workspace` CLI has a separate native before-script runner and a checked
-Python adapter for plugins and custom builders.
-<!-- /port --><!-- port:java -->The local CLI runs `before_script` through native child-process services and
-supports inherited pane before commands. Python plugins and custom builders use
-the explicit tmuxp bridge with version and import-path checks before mutation.
-Their arbitrary effects remain outside native rollback guarantees. Native load
-reports owned cleanup and retained borrowed-state changes; it cannot reverse
-shell side effects.
-<!-- /port --><!-- port:ts,go,java -->
-<!-- /port --><!-- port:ts -->The adapter expands common fields and resolves `workspace_builder_paths`
-relative to the workspace file. Explicit custom builders may omit `windows`
-and consume their own configuration. Append keeps the authenticated current
-session across input files. Python extension append rejects `before_script`;
-run that script separately. Native append supports before scripts.
-
-Extension output is streamed and retained within the CLI's capture limit.
-Progress shows a workspace label without native pane counters. Results describe
-observed changes, which may include concurrent work; the CLI does not claim
-ownership or roll back extension effects. See [output](../../reference/output/)
-and [compatibility status](../../reference/compatibility/) for the result fields
-and cancellation behavior.
-
-The separate `@libtmux/workspace` library's apply policies cover ownership,
-pruning and command replay; they do not implement Python hooks.
-<!-- /port --><!-- port:rs -->The library builder does not import Python plugins or custom workspace builders.
-The local Rust CLI runs those extensions through a checked tmuxp 1.74.0 bridge.
-Append retains the borrowed session and checks its daemon identity before
-extension imports and again before building. A missing or replaced target is
-rejected. These checks do not constrain mutations performed by extension code.
-<!-- /port --><!-- port:go -->Native append retains its borrowed session and rechecks it before each build.
-The Python adapter checks the borrowed daemon and session before importing
-extensions and after constructing the builder. Plugin append with a document
-`before_script` key is unavailable, including an empty or null value. These
-checks do not constrain arbitrary plugin code or make its later execution
-atomic against an external server replacement.
-<!-- /port --><!-- port:dotnet -->The native builder exposes pane-readiness behavior through its own options.
-Python plugins, before_script, and custom Python builder imports are
-unsupported. Similar readiness option names do not establish full hook parity.
-<!-- /port --><!-- port:cxx -->The source consumer does not run Python plugin or builder imports.
-Session-building code can be extended in C++, but that is a distinct interface
-from tmuxp workspace hook configuration.
-<!-- /port --><!-- port:swift -->The Swift model does not load Python plugins, custom builders, or before_script.
-Its cleanup policy is a native builder concern: it attempts scoped rollback and
-reports original and cleanup failures when both occur.
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->
-See the [native builder behavior](../../internals/topics/) and [configuration
-<!-- /port --><!-- port:ts -->source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-<!-- /port --><!-- port:rs -->source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-<!-- /port --><!-- port:go -->source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-<!-- /port --><!-- port:dotnet -->source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-<!-- /port --><!-- port:cxx -->source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-<!-- /port --><!-- port:swift -->source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->before using these fields through application code.
-<!-- /port --><!-- port:java -->See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../../internals/topics/). Its schema is not the CLI configuration
-contract.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Reference source
+## Reference source
 
 [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [registry.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/registry.py); [protocol.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/protocol.py); [options.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/options.py); [plugins.md](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/docs/topics/plugins.md).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Use `before_script` when setup must finish successfully before configured
+windows are built. The command is split into an executable and arguments;
+shell operators require an explicit shell.
+
+```yaml title="hooks.yaml"
+session_name: hooks-example
+before_script: /bin/sh -c 'printf bootstrap-ready'
+windows:
+  - window_name: shell
+    panes: [null]
+```
+
+The CLI checks the child process status. A failure stops that workspace's
+build. The result describes retained effects; an earlier input or borrowed
+session can still exist. A pane's `shell_command` only sends input and does
+not provide this process-status guarantee.
+
+## Paths and output
+
+A relative script path beginning with `.` is resolved from the workspace file.
+The script's working directory uses the configured session directory when
+present, otherwise the invocation directory. The script runs before workspace
+pane commands. Reusing an existing session does not replay its bootstrap.
+
+Machine output captures or streams child output through the CLI protocol.
+Read [output](../../reference/output/) before parsing bootstrap records.
+
+## Prompt readiness
+
+The `pane_readiness` setting under `workspace_builder_options` accepts `auto`,
+`always` or `never`.
+It controls a bounded wait before initial pane input. It does not wait for a
+server process to accept connections. Commands can still be delivered when
+the prompt wait expires.
+
+## Optional extensions
+
+<!-- port:ts,rs,go,java,dotnet -->
+Nonempty `plugins` or `workspace_builder` values select the optional Python
+extension runtime. Set `TMUX_WORKSPACE_PYTHON` to an interpreter with a compatible
+tmuxp 1.74 installation. Ordinary documents use the native builder.
+
+Extensions run executable code and can make changes outside the CLI's own
+tracked operations. Inspect reported effects and errors before retrying them.
+<!-- /port -->
+<!-- port:cxx,swift -->
+Plugin and custom-builder execution is unsupported. The CLI refuses those
+execution fields instead of treating them as successful native work. The
+optional [inspection shell](../../cli/shell/) is a separate feature.
+<!-- /port -->
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/configuration/index.md b/site/src/content/_workspace-shared/workspace/configuration/index.md
index c40996af..f4edf15a 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/index.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/index.md
@@ -1,33 +1,15 @@
 ---
-description: Tmuxp workspace configuration, field meanings, defaults, and execution behavior.
+description: Define the session, windows, panes and commands loaded by the workspace CLI.
 product: workspace
 sidebar:
   group: Configuration
-  label: Overview
+  label: Workspace configuration
   order: 30
 tableOfContents: true
 title: Workspace configuration
-ports:
-  ts:
-    description: Tmuxp workspace configuration and current TypeScript builder compatibility.
-  rs:
-    description: Tmuxp workspace configuration and current Rust builder compatibility.
-  go:
-    description: Tmuxp workspace configuration and current Go builder compatibility.
-  java:
-    description: Tmuxp workspace configuration and current Java builder compatibility.
-  dotnet:
-    description: Tmuxp workspace configuration and current .NET builder compatibility.
-  cxx:
-    description: Tmuxp workspace configuration and current C++ builder compatibility.
-  swift:
-    description: Tmuxp workspace configuration and current Swift builder compatibility.
 ---
 
-<!-- port:py -->This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 A workspace file describes one tmux session, its windows and panes, and the
 commands sent to them. YAML and JSON carry the same field names. Save this
 complete example as [`workspace.yaml`](../guides/installation/#create-the-input):
@@ -115,51 +97,77 @@ Configuration conversion should preserve the source mapping, including extension
 keys; loading that mapping requires separate support for every execution
 feature.
 
-<!-- port:ts -->## Current TypeScript builder
-<!-- /port --><!-- port:rs -->## Current Rust builder
-<!-- /port --><!-- port:go -->## Current Go builder
-<!-- /port --><!-- port:java -->## Native Java CLI
-<!-- /port --><!-- port:dotnet -->## Current .NET builder
-<!-- /port --><!-- port:cxx -->## Current C++ builder
-<!-- /port --><!-- port:swift -->## Current Swift builder
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts -->`@libtmux/workspace` validates a strict subset. Its apply operation reconciles a
-session using ownership and command policies, which differs from tmuxp load. Its
-YAML helper requires Bun; Node callers need a separate YAML decoder.
-<!-- /port --><!-- port:rs -->`tmux-workspace` parses a configuration subset and records unknown keys in
-`unsupported_keys`. It does not execute those keys. Building creates a new
-session; a failure after creation can leave partial state.
-<!-- /port --><!-- port:go -->The Go workspace package rejects unknown fields. It supports a configuration
-subset, but does not perform tmuxp variable expansion or run Python plugins. Its
-builder can leave partial state after an error.
-<!-- /port --><!-- port:java -->The local `tmux-workspace` CLI validates its native configuration before scripts
-run or tmux state changes. It supports the session, window, pane and command
-fields described in the sections below. Unsupported native keys fail explicitly;
-Python plugin/custom-builder inputs use the separately selected extension path.
-Generic conversion preserves document fields without proving native execution.
-<!-- /port --><!-- port:dotnet -->`LibTmux.Workspace` rejects unknown or duplicate keys and unsupported value
-shapes. Its parser and builder cover a subset of this reference. Build errors
-can expose a partial result; there is no automatic rollback.
-<!-- /port --><!-- port:cxx -->The C++ workspace consumer is a source-tree library target. Its YAML parser
-rejects fields outside its supported subset. Building can leave earlier tmux
-changes in place after failure.
-<!-- /port --><!-- port:swift -->`TmuxWorkspace` supports JSON decoding and optional YAML decoding through the
-`YAMLWorkspaces` trait. Unknown keys can be ignored. The model covers names,
-directories, layouts, and commands, with narrower shapes than tmuxp.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->See the [native builder behavior](../internals/topics/) and [configuration
-<!-- /port --><!-- port:ts -->source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-<!-- /port --><!-- port:rs -->source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-<!-- /port --><!-- port:go -->source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-<!-- /port --><!-- port:dotnet -->source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-<!-- /port --><!-- port:cxx -->source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-<!-- /port --><!-- port:swift -->source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->before using these fields through application code.
-<!-- /port --><!-- port:java -->See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../internals/topics/). Its schema is not the CLI configuration
-contract.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Reference source
+## Reference source
 
 [loader.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/loader.py); [validation.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/validation.py); [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+A workspace document describes one tmux session. Save this as `configuration.yaml`:
+
+```yaml title="configuration.yaml"
+session_name: configuration-example
+windows:
+  - window_name: editor
+    layout: even-horizontal
+    panes:
+      - printf ready
+      - null
+```
+
+Load it on the private socket from the
+[installation walkthrough](../guides/installation/):
+
+```console
+$ tmux-workspace load \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    -d \
+    --json \
+    configuration.yaml
+```
+
+The CLI parses the document and validates its execution fields before creating
+windows and sending commands. YAML and JSON use the same field names. A successful
+load means construction and command delivery completed; pane applications can
+still be starting or failing independently.
+
+## Choose the fields for your task
+
+- [Session](./session/) sets the name, shared options and environment.
+- [Windows](./windows/) sets indexes, layouts and option timing.
+- [Panes](./panes/) defines commands, launch shells and focus.
+- [Commands](./commands/) controls ordering, Enter and delays.
+- [Environment](./environment/) separates loader settings from pane variables.
+- [Directories](./directories/) explains discovery and working directories.
+- [Layouts](./layouts/) arranges the panes.
+- [Hooks](./hooks/) runs checked bootstrap programs and optional extensions.
+
+## CLI and application code
+
+These pages describe the `tmux-workspace` executable. Application code uses the
+separate [workspace library](../internals/), whose accepted fields and build
+semantics have their own contract. A successful generic [conversion](../cli/convert/)
+preserves document values; it does not validate that a loader can execute them.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/configuration/layouts.md b/site/src/content/_workspace-shared/workspace/configuration/layouts.md
index b42f774e..96d8c7ed 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/layouts.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/layouts.md
@@ -1,33 +1,15 @@
 ---
-description: Tmuxp workspace layouts and focus, field meanings, defaults, and execution behavior.
+description: Arrange panes with tmux layout names or a saved layout.
 product: workspace
 sidebar:
   group: Configuration
-  label: Layouts and focus
+  label: Window layouts
   order: 37
 tableOfContents: true
-title: Workspace layouts and focus
-ports:
-  ts:
-    description: Tmuxp workspace layouts and focus and current TypeScript builder compatibility.
-  rs:
-    description: Tmuxp workspace layouts and focus and current Rust builder compatibility.
-  go:
-    description: Tmuxp workspace layouts and focus and current Go builder compatibility.
-  java:
-    description: Tmuxp workspace layouts and focus and current Java builder compatibility.
-  dotnet:
-    description: Tmuxp workspace layouts and focus and current .NET builder compatibility.
-  cxx:
-    description: Tmuxp workspace layouts and focus and current C++ builder compatibility.
-  swift:
-    description: Tmuxp workspace layouts and focus and current Swift builder compatibility.
+title: Window layouts
 ---
 
-<!-- port:py -->This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 A window's `"layout"` chooses how tmux arranges its panes. Named layouts adapt to
 the window size; explicit layout strings describe geometry more directly. The
 selected tmux version and terminal dimensions affect the final result.
@@ -96,54 +78,60 @@ $ tmux -L layout-example list-windows -t '=layout-example'
 
 This command assumes the sample workspace was loaded on the dedicated
 layout-example socket. Use [load](../../cli/load/) to select that socket, then
-inspect panes as needed. A successful load does not prove every native port
-honors the same focus/index/options policy.
-
-<!-- port:ts -->## Current TypeScript builder
-<!-- /port --><!-- port:rs -->## Current Rust builder
-<!-- /port --><!-- port:go -->## Current Go builder
-<!-- /port --><!-- port:java -->## Native Java CLI
-<!-- /port --><!-- port:dotnet -->## Current .NET builder
-<!-- /port --><!-- port:cxx -->## Current C++ builder
-<!-- /port --><!-- port:swift -->## Current Swift builder
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts -->Apply handles supported layouts/focus/options, but planWorkspace describes
-topology changes only. It does not enumerate command, option, layout, or focus
-changes.
-<!-- /port --><!-- port:rs -->Layout and focus are part of the native build plan. Explicit and default
-initial-window indexes need compatibility work; use a fresh tmux inspection
-rather than the parsed model to check them.
-<!-- /port --><!-- port:go -->The parser validates layouts, and the builder applies them through tmux. Global
-options are set after initial session creation, so options that affect that
-first window can differ from later windows.
-<!-- /port --><!-- port:java -->The local CLI validates layout syntax, checksum, structure and pane capacity
-before scripts or session mutation. Version-sensitive named layouts use the
-selected daemon. tmux owns geometry correction and pruning. All panes in a
-window are created and its layout is applied before commands are sent; focus
-and `options_after` follow command delivery.
-<!-- /port --><!-- port:dotnet -->Rejected layouts are reported in `WorkspaceResult.Unsupported` while the
-corresponding windows remain available. Other build failures raise an exception
-with partial result information.
-<!-- /port --><!-- port:cxx -->Window options precede layout application and options_after follows pane
-creation. Commands address actual pane IDs. Failures report a window position
-and reason without rollback.
-<!-- /port --><!-- port:swift -->Layout descriptions are passed through the builder. Returned Session values are
-snapshots; refresh after construction to inspect all created windows and panes.
-Do not infer focus/index support from layout support.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->See the [native builder behavior](../../internals/topics/) and [configuration
-<!-- /port --><!-- port:ts -->source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-<!-- /port --><!-- port:rs -->source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-<!-- /port --><!-- port:go -->source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-<!-- /port --><!-- port:dotnet -->source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-<!-- /port --><!-- port:cxx -->source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-<!-- /port --><!-- port:swift -->source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->before using these fields through application code.
-<!-- /port --><!-- port:java -->See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../../internals/topics/). Its schema is not the CLI configuration
-contract.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Reference source
+inspect panes as needed.
+
+## Reference source
 
 [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [main-pane-height.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/main-pane-height.yaml); [main-pane-height-percentage.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/main-pane-height-percentage.yaml); [focus-window-and-panes.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/focus-window-and-panes.yaml); [window-index.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/window-index.yaml).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Choose a layout for each window. `even-horizontal` gives panes equal widths:
+
+```yaml title="layouts.yaml"
+session_name: layouts-example
+windows:
+  - window_name: work
+    layout: even-horizontal
+    panes: [null, null, null]
+```
+
+Other common tmux names include `even-vertical`, `main-horizontal`,
+`main-vertical` and `tiled`. Full names avoid version-dependent abbreviation
+ambiguity. Available names follow the selected tmux daemon.
+
+## Saved layouts and terminal size
+
+A captured layout describes pane geometry. Loading validates its syntax and
+pane capacity, then tmux applies it to the actual window size. Resizing can
+change the final dimensions. Use a named layout when exact saved geometry is
+unnecessary.
+
+Set window and pane `focus` explicitly when the active target matters. Layout
+arrangement and active-pane selection are different settings.
+
+[Capture](../../cli/freeze/) can save a running layout; inspect it before
+[reloading](../../guides/export-session/) on a smaller terminal.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/configuration/panes.md b/site/src/content/_workspace-shared/workspace/configuration/panes.md
index 5fec0c94..197b00a4 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/panes.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/panes.md
@@ -1,43 +1,18 @@
 ---
-description: Tmuxp pane configuration, field meanings, defaults, and execution behavior.
+description: Choose pane commands, launch settings and focus.
 product: workspace
 sidebar:
   group: Configuration
-  label: Panes
+  label: Pane configuration
   order: 33
 tableOfContents: true
 title: Pane configuration
-ports:
-  ts:
-    description: Tmuxp pane configuration and current TypeScript builder compatibility.
-  rs:
-    description: Tmuxp pane configuration and current Rust builder compatibility.
-  go:
-    description: Tmuxp pane configuration and current Go builder compatibility.
-  java:
-    description: Tmuxp pane configuration and current Java builder compatibility.
-  dotnet:
-    description: Tmuxp pane configuration and current .NET builder compatibility.
-  cxx:
-    description: Tmuxp pane configuration and current C++ builder compatibility.
-  swift:
-    description: Tmuxp pane configuration and current Swift builder compatibility.
 ---
 
-<!-- port:py -->This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 A pane can be a command string, a list of commands, or a mapping of settings.
 Each item in the window's `"panes"` list creates one pane; a command list inside
 that item describes several commands in that same pane.
-<!-- port:dotnet -->
-The native .NET CLI creates panes in configuration order. This also holds for
-windows with three or more panes: each new split follows the preceding pane.
-`pane-base-index` changes their starting index; `focus: true` selects a
-configured pane without changing creation order. Layouts determine the final
-geometry. See the [native load source](https://github.com/libtmux/libtmux-dotnet/blob/4ac82a5b82fd8cf68d31c70a2a3eb43c587cd7c0/src/LibTmux.Workspace.Cli/ExecutionCommands.cs).
-<!-- /port -->
 ```yaml
 session_name: pane-example
 start_directory: ./
@@ -99,50 +74,67 @@ A successful build confirms command delivery, not application readiness or
 command exit status. See [commands](../commands/) for Enter, timing, and
 history, and [environment](../environment/) for launch-map selection.
 
-<!-- port:ts -->## Current TypeScript builder
-<!-- /port --><!-- port:rs -->## Current Rust builder
-<!-- /port --><!-- port:go -->## Current Go builder
-<!-- /port --><!-- port:java -->## Native Java CLI
-<!-- /port --><!-- port:dotnet -->## Current .NET builder
-<!-- /port --><!-- port:cxx -->## Current C++ builder
-<!-- /port --><!-- port:swift -->## Current Swift builder
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts -->A pane is a string or supported mapping. Null, bare command lists, shell,
-environment, and timed command dictionaries are not the complete tmuxp shapes
-accepted here.
-<!-- /port --><!-- port:rs -->Pane maps and command strings are supported, but tmuxp bare command lists and
-special blank forms have normalization differences. Pane shell and environment
-execution require their own compatibility checks.
-<!-- /port --><!-- port:go -->A shell on the first pane and window_shell describe the same initial launch; the
-Go parser rejects setting both. Tmuxp allows the pane shell to override. Blank
-forms and command lists need per-shape compatibility checks.
-<!-- /port --><!-- port:java -->The local CLI accepts null and `blank`/`pane`/`empty` shorthand, command strings,
-command lists and pane mappings. Mappings support directories, launch
-environments, focus, before commands, history policy, Enter and delays. `shell:`
-and `pane_shell:` are aliases and cannot both be set. A successful load confirms
-command delivery, not a shell command's completion or exit status.
-<!-- /port --><!-- port:dotnet -->Pane values support the package's command and directory shapes. The full set of
-tmuxp shorthand, shell, environment, and command-mapping forms is not accepted.
-<!-- /port --><!-- port:cxx -->Native pane commands support Enter, pause, and history metadata. Exact shorthand
-and shell/environment combinations still need the parser and execution behavior
-checked separately.
-<!-- /port --><!-- port:swift -->The first pane is created with its window directory; split panes can supply a
-pane directory. This differs from tmuxp, which also lets the first pane override
-its directory. Command decoding accepts fewer forms.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->See the [native builder behavior](../../internals/topics/) and [configuration
-<!-- /port --><!-- port:ts -->source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-<!-- /port --><!-- port:rs -->source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-<!-- /port --><!-- port:go -->source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-<!-- /port --><!-- port:dotnet -->source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-<!-- /port --><!-- port:cxx -->source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-<!-- /port --><!-- port:swift -->source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->before using these fields through application code.
-<!-- /port --><!-- port:java -->See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../../internals/topics/). Its schema is not the CLI configuration
-contract.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Reference source
+## Reference source
 
 [loader.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/loader.py); [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [blank-panes.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/blank-panes.yaml); [pane-shell.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/pane-shell.yaml).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Each entry in a window's `panes` list describes one pane. A string is a command;
+`null` leaves a blank shell pane. A mapping provides launch and command settings.
+
+```yaml title="panes.yaml"
+session_name: panes-example
+windows:
+  - window_name: work
+    layout: even-horizontal
+    panes:
+      - null
+      - shell: /bin/sh
+        focus: true
+        shell_command:
+          - printf ready
+          - printf second
+```
+
+The second pane launches `/bin/sh`, receives both commands in order and becomes
+the active pane. A command list inside one pane does not create extra panes.
+
+## Overrides
+
+- `start_directory` overrides the inherited working directory.
+- `shell` overrides the window's launch command.
+- `environment` supplies the pane's launch environment map.
+- `shell_command_before` adds setup after session and window setup.
+- `enter`, `sleep_before` and `sleep_after` supply command defaults.
+- `suppress_history` overrides the inherited history policy.
+
+Set focus explicitly when automation depends on which pane is selected. Use
+returned pane IDs for later operations instead of assuming that creation order
+is a stable tmux ID.
+
+Read [commands](../commands/) for Enter and delay behavior and
+[environment](../environment/) for variable handling.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/configuration/session.md b/site/src/content/_workspace-shared/workspace/configuration/session.md
index 67e0d052..e04c1260 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/session.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/session.md
@@ -1,33 +1,15 @@
 ---
-description: Tmuxp session configuration, field meanings, defaults, and execution behavior.
+description: Name a workspace and apply session options and environment.
 product: workspace
 sidebar:
   group: Configuration
-  label: Session
+  label: Session configuration
   order: 31
 tableOfContents: true
 title: Session configuration
-ports:
-  ts:
-    description: Tmuxp session configuration and current TypeScript builder compatibility.
-  rs:
-    description: Tmuxp session configuration and current Rust builder compatibility.
-  go:
-    description: Tmuxp session configuration and current Go builder compatibility.
-  java:
-    description: Tmuxp session configuration and current Java builder compatibility.
-  dotnet:
-    description: Tmuxp session configuration and current .NET builder compatibility.
-  cxx:
-    description: Tmuxp session configuration and current C++ builder compatibility.
-  swift:
-    description: Tmuxp session configuration and current Swift builder compatibility.
 ---
 
-<!-- port:py -->This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 The root mapping names the session and supplies defaults inherited by its
 windows and panes. The file's name is independent of `"session_name"`: loading
 [`project.yaml`](../../guides/discovery/) can create a session named `development`.
@@ -100,55 +82,70 @@ environments. Read [directories](../directories/), [commands](../commands/), and
 Python scripts, plugins, and custom builder references execute code. Their exact
 timing and runtime requirements are in [hooks and builders](../hooks/).
 
-<!-- port:ts -->## Current TypeScript builder
-<!-- /port --><!-- port:rs -->## Current Rust builder
-<!-- /port --><!-- port:go -->## Current Go builder
-<!-- /port --><!-- port:java -->## Native Java CLI
-<!-- /port --><!-- port:dotnet -->## Current .NET builder
-<!-- /port --><!-- port:cxx -->## Current C++ builder
-<!-- /port --><!-- port:swift -->## Current Swift builder
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts -->The local CLI supports session environment and before scripts. Explicit plugins
-and custom builders use the optional Python bridge described in
-[hooks and builders](../hooks/); custom builders may omit `windows`.
-<!-- /port --><!-- port:java -->The local CLI accepts session identity, directories, environment, session and
-global options, `before_script`, inherited before commands and history policy.
-Python plugins and custom builders use an explicit, version-checked runtime;
-they do not run through the native builder. Existing-session reuse and append
-follow the [load contract](../../cli/load/), including retained partial effects.
-<!-- /port --><!-- port:ts,java -->
-<!-- /port --><!-- port:ts -->The separate `@libtmux/workspace` library represents session name, start
-directory, options and windows. Environment, plugins, before_script and builder
-selection remain outside that library's strict schema.
-<!-- /port --><!-- port:rs -->Session options, environment, directories, and pre-pane commands have native
-fields. Python scripts, plugins, and builder selection need separate execution
-support; retaining an unknown key does not run it.
-<!-- /port --><!-- port:go -->Global/session options, environment, inherited directories, and pre-pane
-commands are supported. `"before_script"`, `"plugins"`, and custom Python builder
-fields are rejected.
-<!-- /port --><!-- port:dotnet -->The parser supports session names, directories, scalar options, and windows.
-Python hooks/plugins, the complete environment runtime, and discovery are
-outside its model.
-<!-- /port --><!-- port:cxx -->Session names, directories, environment, options, and command-related settings
-have native fields. The consumer does not import Python plugins or custom
-builders.
-<!-- /port --><!-- port:swift -->The model includes session name, directory, and windows. Session
-environment/options, plugins, and custom builder fields are outside that model
-and can be ignored by decoding.
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->
-See the [native builder behavior](../../internals/topics/) and [configuration
-<!-- /port --><!-- port:ts -->source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-<!-- /port --><!-- port:rs -->source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-<!-- /port --><!-- port:go -->source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-<!-- /port --><!-- port:dotnet -->source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-<!-- /port --><!-- port:cxx -->source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-<!-- /port --><!-- port:swift -->source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->before using these fields through application code.
-<!-- /port --><!-- port:java -->See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../../internals/topics/). Its schema is not the CLI configuration
-contract.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Reference source
+## Reference source
 
 [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [loader.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/loader.py); [load.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/load.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Set `session_name` and an ordered, nonempty `windows` list. Use a simple name
+without tmux target separators such as `:` and `.`.
+
+```yaml title="session.yaml"
+session_name: session-example
+environment:
+  PROJECT_MODE: development
+options:
+  status: false
+windows:
+  - window_name: shell
+    panes: [null]
+```
+
+## Session fields
+
+| Field | Effect |
+| --- | --- |
+| `session_name` | Session to create or reuse |
+| `windows` | Windows to construct in order |
+| `start_directory` | Starting directory inherited by child configuration |
+| `environment` | Variables supplied to the workspace |
+| `options` | Options applied to this session |
+| `global_options` | Options applied globally on the selected tmux server |
+| `shell_command_before` | Commands prepended to each pane's commands |
+| `suppress_history` | History policy inherited by windows and panes |
+| `before_script` | Checked bootstrap process |
+| `workspace_builder_options` | Builder settings such as prompt readiness |
+
+Use `global_options` only when every session on that server should share the
+change. Select a private socket for examples and automated jobs.
+
+An existing session is reused under the loader's policy. Use `load -s NAME`
+when a second copy needs another name. Loading does not remove unrelated
+sessions or reconcile away extra windows.
+
+Read [environment](../environment/), [commands](../commands/) and
+[hooks](../hooks/) for the behavior behind those fields.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/configuration/windows.md b/site/src/content/_workspace-shared/workspace/configuration/windows.md
index fa0ed384..64b3d9d5 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/windows.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/windows.md
@@ -1,33 +1,15 @@
 ---
-description: Tmuxp window configuration, field meanings, defaults, and execution behavior.
+description: Set window names, indexes, layouts, options and focus.
 product: workspace
 sidebar:
   group: Configuration
-  label: Windows
+  label: Window configuration
   order: 32
 tableOfContents: true
 title: Window configuration
-ports:
-  ts:
-    description: Tmuxp window configuration and current TypeScript builder compatibility.
-  rs:
-    description: Tmuxp window configuration and current Rust builder compatibility.
-  go:
-    description: Tmuxp window configuration and current Go builder compatibility.
-  java:
-    description: Tmuxp window configuration and current Java builder compatibility.
-  dotnet:
-    description: Tmuxp window configuration and current .NET builder compatibility.
-  cxx:
-    description: Tmuxp window configuration and current C++ builder compatibility.
-  swift:
-    description: Tmuxp window configuration and current Swift builder compatibility.
 ---
 
-<!-- port:py -->This page documents Python tmuxp configuration at the pinned reference revision.
-Use tmuxp for the command examples below.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Each item in `"windows"` describes one window and its ordered panes. Set
 `"window_name"` when the name matters; an omitted name lets tmux choose it.
 `"window_index"` selects a tmux numeric index independently of the item's position
@@ -80,9 +62,7 @@ creates splits for later panes. A first-pane override therefore matters during
 new-window, not only while creating splits.
 
 A pane shell overrides window_shell. Window environment is used when the pane
-has no environment map; providing a pane map selects that map instead. These
-rules have native-port differences, so use the current builder note on this
-page.
+has no environment map; providing a pane map selects that map instead.
 
 ## Index, layout, and focus
 
@@ -96,50 +76,66 @@ such as synchronize-panes that should take effect after individual setup
 commands. [Layouts](../layouts/) explains named layouts, dimensions, and focus;
 [panes](../panes/) describes the pane forms accepted inside a window.
 
-<!-- port:ts -->## Current TypeScript builder
-<!-- /port --><!-- port:rs -->## Current Rust builder
-<!-- /port --><!-- port:go -->## Current Go builder
-<!-- /port --><!-- port:java -->## Native Java CLI
-<!-- /port --><!-- port:dotnet -->## Current .NET builder
-<!-- /port --><!-- port:cxx -->## Current C++ builder
-<!-- /port --><!-- port:swift -->## Current Swift builder
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts -->Names, directories, layout, focus, options, pre-pane commands, and panes are
-supported. Native apply matches windows by position, not tmux numeric index, and
-can reuse existing windows.
-<!-- /port --><!-- port:rs -->Window index, layout, focus, options, environment, and directories have native
-fields. The current creation plan has first-window index differences, so
-successful parsing does not prove requested indexes materialize.
-<!-- /port --><!-- port:go -->Window index, shell, focus, layout, options, options_after, and environment have
-native support. Global options are applied after the initial session exists, and
-pane/window environment values are written to the session.
-<!-- /port --><!-- port:java -->The local CLI accepts window names, explicit indexes, layouts, focus,
-directories, launch environments, options, `options_after` and `window_shell`.
-Window environment supplies the launch map when a pane has no environment map.
-A pane override replaces that map. Native layout preflight precedes scripts;
-`options_after` runs after pane command delivery.
-<!-- /port --><!-- port:dotnet -->Windows, layouts, focus, scalar options, and panes are supported. A bootstrap
-window allows session options to be applied before configured windows. Hooks can
-observe that temporary window.
-<!-- /port --><!-- port:cxx -->Names, indexes, directories, environment, options, layouts, focus, and
-options_after are supported in the subset. Inspect actual creation order and
-current tmux state when matching reference semantics.
-<!-- /port --><!-- port:swift -->Windows have names, directories, layout, and panes. Indexes, environment,
-options, and focus settings from the tmuxp reference are not all represented.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->See the [native builder behavior](../../internals/topics/) and [configuration
-<!-- /port --><!-- port:ts -->source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/src/config.ts)
-<!-- /port --><!-- port:rs -->source](https://github.com/libtmux/libtmux-rs/blob/4a9afac1d82d9a6a9af16099e7b846e69f0e6388/crates/tmux-workspace/src/config.rs)
-<!-- /port --><!-- port:go -->source](https://github.com/libtmux/libtmux-go/blob/bb48780c49652d6b7a17884f19a93c269f04a688/workspace/workspace.go)
-<!-- /port --><!-- port:dotnet -->source](https://github.com/libtmux/libtmux-dotnet/blob/b71b9654f41785c93717e454cbf176672b3d634a/src/LibTmux.Workspace/WorkspaceYamlParser.cs)
-<!-- /port --><!-- port:cxx -->source](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/src/tmuxp.cpp)
-<!-- /port --><!-- port:swift -->source](https://github.com/libtmux/libtmux-swift/blob/94b9e4cc436dda8e18e064179ae7d26e55bbbd73/Sources/TmuxWorkspace/Workspace.swift)
-<!-- /port --><!-- port:ts,rs,go,dotnet,cxx,swift -->before using these fields through application code.
-<!-- /port --><!-- port:java -->See the [CLI configuration parser](https://github.com/libtmux/libtmux-java/blob/2d7e8028986b99c8e9496dc40b5d1e90fb2368c9/workspace-cli/src/main/java/io/github/libtmux/workspace/cli/WorkspacePlan.java).
-Application code using the lower-level workspace library has a separate
-[builder API](../../internals/topics/). Its schema is not the CLI configuration
-contract.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- /port -->## Reference source
+## Reference source
 
 [classic.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/builder/classic.py); [loader.py](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/workspace/loader.py); [2-pane-synchronized.yaml](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/2-pane-synchronized.yaml).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Each item in `windows` creates one window with its own ordered pane list.
+Set `window_index` when the tmux index matters independently of list position.
+
+```yaml title="windows.yaml"
+session_name: windows-example
+windows:
+  - window_name: tools
+    window_index: 2
+    layout: even-horizontal
+    focus: true
+    options:
+      automatic-rename: false
+    options_after:
+      synchronize-panes: true
+    panes:
+      - printf left
+      - printf right
+```
+
+`options` applies during construction. `options_after` applies after initial
+pane commands, which is useful for enabling synchronized typing after each pane
+has received its own setup. Later input in a synchronized pane can reach the
+other panes in that window.
+
+## Launch settings
+
+`start_directory` supplies a directory for panes that do not override it.
+`window_shell` supplies their launch command; a pane's `shell` overrides it.
+Set `environment` for a window-wide launch map and read
+[environment inheritance](../environment/) before overriding it per pane.
+
+Use distinct explicit indexes. `focus: true` selects the window after building.
+An explicit [layout](../layouts/) makes the intended arrangement clear across
+terminal sizes. [Pane configuration](../panes/) controls each pane's contents.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/examples/gallery.md b/site/src/content/_workspace-shared/workspace/examples/gallery.md
index 0000fdae..2679e550 100644
--- a/site/src/content/_workspace-shared/workspace/examples/gallery.md
+++ b/site/src/content/_workspace-shared/workspace/examples/gallery.md
@@ -1,35 +1,27 @@
 ---
-description: Pinned YAML examples, JSON counterparts, and execution prerequisites.
+description: Start from complete configurations for pane layout, commands and environment.
 product: workspace
 sidebar:
   group: Examples
-  label: Workspace example gallery
+  label: Workspace examples
   order: 31
 tableOfContents: true
-title: Workspace example gallery
+title: Workspace examples
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 The examples below reproduce the pinned tmuxp YAML fixture corpus. Each record
 links to its source and, where present, its JSON twin. They illustrate
 configuration features; they are not all self-contained runnable projects.
 
 The `minimal` fixture and several other files omit window names despite the
 validator requiring them. Treat these as normalization and compatibility probes,
-<!-- port:py -->not a promise that every fixture passes every load path. The [installation
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->not a promise that every fixture passes every load path. Where this port's
-native parser accepts a fixture below, that establishes only that its document
-parses, not that it fully executes. The [installation
-<!-- /port -->walkthrough](../../guides/installation/) supplies a complete runnable starting
+not a promise that every fixture passes every load path. The [installation
+walkthrough](../../guides/installation/) supplies a complete runnable starting
 file.
 
 ## 2-pane-synchronized
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/2-pane-synchronized.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/2-pane-synchronized.json).
 
 ```yaml
@@ -45,9 +37,9 @@ windows:
 
 ## 2-pane-vertical
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/2-pane-vertical.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/2-pane-vertical.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/2-pane-vertical.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/2-pane-vertical.json).
 
 ```yaml
 session_name: 2-pane-vertical
@@ -59,9 +51,7 @@ windows:
 ```
 
 ## 3-pane
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/3-pane.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/3-pane.json).
 
 ```yaml
@@ -81,9 +71,9 @@ windows:
 
 ## 4-pane
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/4-pane.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/4-pane.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/4-pane.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/4-pane.json).
 
 ```yaml
 session_name: 4-pane-split
@@ -102,9 +92,7 @@ windows:
 ```
 
 ## blank-panes
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/blank-panes.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/blank-panes.json).
 
 ```yaml
@@ -139,9 +127,9 @@ windows:
 
 ## env-variables
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/env-variables.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/env-variables.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/env-variables.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/env-variables.json).
 
 ```yaml
 start_directory: "${PWD}/test"
@@ -164,9 +152,7 @@ windows:
 ```
 
 ## focus-window-and-panes
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/focus-window-and-panes.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/focus-window-and-panes.json).
 
 ```yaml
@@ -194,9 +180,9 @@ windows:
 
 ## main-pane-height-percentage
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/main-pane-height-percentage.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/main-pane-height-percentage.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/main-pane-height-percentage.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/main-pane-height-percentage.json).
 
 ```yaml
 session_name: main-pane-height
@@ -217,9 +203,7 @@ windows:
 ```
 
 ## main-pane-height
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/main-pane-height.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/main-pane-height.json).
 
 ```yaml
@@ -242,9 +226,9 @@ windows:
 
 ## minimal
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/minimal.yaml).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/minimal.yaml).
 
 ```yaml
 session_name: My tmux session
@@ -254,9 +238,7 @@ windows:
 ```
 
 ## options
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/options.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/options.json).
 
 ```yaml
@@ -282,9 +264,7 @@ windows:
 ```
 
 ## pane-shell
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/pane-shell.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/pane-shell.json).
 
 ```yaml
@@ -314,9 +294,9 @@ windows:
 
 ## plugin-system
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/plugin-system.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/plugin-system.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/plugin-system.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/plugin-system.json).
 
 ```yaml
 session_name: plugin-system
@@ -335,9 +315,7 @@ windows:
 ```
 
 ## session-environment
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/session-environment.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/session-environment.json).
 
 ```yaml
@@ -364,9 +342,9 @@ windows:
 
 ## shorthands
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/shorthands.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/shorthands.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/shorthands.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/shorthands.json).
 
 ```yaml
 session_name: shorthands
@@ -381,9 +359,7 @@ windows:
 ```
 
 ## skip-send-pane-level
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/skip-send-pane-level.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/skip-send-pane-level.json).
 
 ```yaml
@@ -400,9 +376,9 @@ windows:
 
 ## skip-send
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/skip-send.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/skip-send.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/skip-send.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/skip-send.json).
 
 ```yaml
 session_name: Skip command execution (command-level)
@@ -417,9 +393,7 @@ windows:
 ```
 
 ## sleep-pane-level
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/sleep-pane-level.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/sleep-pane-level.json).
 
 ```yaml
@@ -438,9 +412,9 @@ windows:
 
 ## sleep-virtualenv
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/sleep-virtualenv.yaml).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/sleep-virtualenv.yaml).
 
 ```yaml
 session_name: virtualenv
@@ -457,9 +431,7 @@ windows:
 ```
 
 ## sleep
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/sleep.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/sleep.json).
 
 ```yaml
@@ -482,9 +454,7 @@ windows:
 ```
 
 ## start-directory
-<!-- port:py -->
 Pinned Python reference fixture. This docs run did not execute its full application environment.
-<!-- /port -->
 [YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/start-directory.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/start-directory.json).
 
 ```yaml
@@ -533,9 +503,9 @@ windows:
 
 ## suppress-history
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/suppress-history.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/suppress-history.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/suppress-history.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/suppress-history.json).
 
 ```yaml
 session_name: suppress
@@ -571,9 +541,9 @@ windows:
 
 ## window-index
 
-<!-- port:py -->Pinned Python reference fixture. This docs run did not execute its full application environment.
+Pinned Python reference fixture. This docs run did not execute its full application environment.
 
-<!-- /port -->[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/window-index.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/window-index.json).
+[YAML source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/window-index.yaml); [JSON source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/examples/window-index.json).
 
 ```yaml
 session_name: Window index example
@@ -602,3 +572,75 @@ upstream evidence, not recommended installation guidance. Review
 [compatibility](../../reference/compatibility/) before adapting these fixtures.
 
 [tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Each configuration below is a complete workspace document. Save it to a file
+and load it on the private socket from the
+[installation walkthrough](../../guides/installation/).
+
+## Two blank panes
+
+```yaml title="gallery-blank.yaml"
+session_name: gallery-blank
+windows:
+  - window_name: work
+    layout: even-horizontal
+    panes: [null, null]
+```
+
+Blank panes open their shells without application-specific prerequisites.
+Change the [layout](../../configuration/layouts/) to arrange them vertically.
+
+## Setup before pane commands
+
+```yaml title="gallery-commands.yaml"
+session_name: gallery-commands
+shell_command_before:
+  - printf setup
+windows:
+  - window_name: shell
+    panes:
+      - shell_command:
+          - printf first
+          - printf second
+```
+
+Both commands run in one pane after its inherited setup. Read
+[command ordering](../../configuration/commands/) before adding delays or
+commands that should remain unsubmitted.
+
+## More complete examples
+
+- [Session options and environment](../../configuration/session/).
+- [Explicit window index and synchronized input](../../configuration/windows/).
+- [Pane launch shell and focus](../../configuration/panes/).
+- [Inherited directories](../../configuration/directories/).
+- [Environment overrides](../../configuration/environment/).
+- [Checked bootstrap process](../../configuration/hooks/).
+
+Use the [workspace library](../../internals/) when application code needs to
+construct sessions directly.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/guides/automation.md b/site/src/content/_workspace-shared/workspace/guides/automation.md
index e1ed9de9..2b3788f9 100644
--- a/site/src/content/_workspace-shared/workspace/guides/automation.md
+++ b/site/src/content/_workspace-shared/workspace/guides/automation.md
@@ -1,5 +1,5 @@
 ---
-description: Python automation and the local native CLI machine protocol.
+description: Run detached commands with explicit inputs and machine-readable results.
 product: workspace
 sidebar:
   group: Guides
@@ -9,39 +9,90 @@ tableOfContents: true
 title: Automate workspace operations
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-For the current Python loader, supply an explicit file, dedicated socket, and
-`-d` to avoid attachment. `--yes` answers yes/no questions; it is not a
-universal replacement for missing session, format, or destination choices.
+<!-- port:py -->
+Pass an explicit workspace file, dedicated socket and `-d` when running tmuxp
+from a script. `--yes` answers confirmations; it does not supply every missing
+choice.
+
+```console
+$ tmuxp load -L workspace-guide -d workspace.yaml
+```
 
-## Read current records
+Use `ls --json` to read discovered workspace records:
 
 ```console
 $ tmuxp ls --json
 ```
 
-Validate the JSON object before consuming its `workspaces` array. Python search
-has different empty-result behavior: no matches can produce no bytes rather than
-`[]`. See [search](../../cli/search/) before relying on a pipeline.
+The output is an object with a `workspaces` array. Search has different empty
+output and error behavior; read [search](../../cli/search/) and
+[exit codes](../../reference/exit-codes/) before building a pipeline.
+
+Use [export and reload](../export-session/) to capture a session. Review the
+resulting commands and paths rather than treating capture as a complete backup.
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Give automation an explicit file, endpoint and attachment choice. Continue the
+[installation walkthrough](../installation/) with this detached operation:
+
+```console
+$ tmux-workspace load \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    -d \
+    --json \
+    workspace.yaml
+```
+
+Check the process exit status, parse its JSON result, then inspect any reported
+partial effects. A failed later input does not imply that earlier sessions
+were removed. Keep stderr separate from the result stream.
+
+## Follow progress
 
-## Proposed native machine protocol
+Use NDJSON when the caller needs records while a load is running:
 
-Local native CLIs provide `--json` and `--ndjson`. Implemented services and
-terminal behavior vary by port. The shared machine contract resolves choices
-from arguments, avoid implicit stdin prompts, keep diagnostics on stderr, and
-prevent child output or attachment from corrupting stdout. The operation result
-must report partial completion instead of claiming rollback.
+```console
+$ tmux-workspace load \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    -d \
+    --ndjson \
+    workspace.yaml
+```
+
+Parse one complete JSON value per line. Treat a closed stream or missing final
+result as incomplete work. Do not infer success from an earlier creation event.
 
-NDJSON load events must be observable while work is still running, followed by
-exactly one terminal record. A buffered array split into lines after completion
-does not meet this requirement. Both output flags together select NDJSON.
+## Make retries deliberate
 
-Read [output](../../reference/output/) for stream shapes and [exit
-behavior](../../reference/exit-codes/) for errors and interruption. [Export and
-reload](../export-session/) distinguishes document encoding from CLI result
-encoding.
+Use a unique session name for independent jobs. Reusing a name follows the
+loader's existing-session policy; it is not a request to reset that session.
+Capture IDs and retained effects from the result before deciding what to clean
+up or retry. Remove only sessions the job owns.
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+Read [output](../../reference/output/) and [errors](../../reference/exit-codes/)
+for the command's machine interface. A pane's process can outlive the CLI and
+can fail after successful command delivery.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/guides/discovery.md b/site/src/content/_workspace-shared/workspace/guides/discovery.md
index e2d504bf..fede26ea 100644
--- a/site/src/content/_workspace-shared/workspace/guides/discovery.md
+++ b/site/src/content/_workspace-shared/workspace/guides/discovery.md
@@ -1,5 +1,5 @@
 ---
-description: Resolve project files, explicit paths, and global workspace names.
+description: Resolve explicit files, project directories and saved workspace names.
 product: workspace
 sidebar:
   group: Guides
@@ -9,10 +9,7 @@ tableOfContents: true
 title: Find saved workspaces
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Use an explicit YAML or JSON file path when you need an unambiguous input. A
 directory resolves its project configuration, and a saved name resolves through
 the tmuxp configuration roots.
@@ -43,3 +40,60 @@ execution and select `-L` or `-S` for an isolated server. [ls](../../cli/ls/),
 concepts with their own result and error behavior.
 
 [tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Use an explicit path, such as [`./workspace.yaml`](../installation/#create-the-input), to select one document.
+Pass a project directory such as `.` to use its [`.tmuxp.yaml`](#list-available-files), [`.tmuxp.yml`](#list-available-files) or
+[`.tmuxp.json`](#list-available-files) configuration. A bare saved name uses the global workspace
+directory.
+
+## List available files
+
+```console
+$ tmux-workspace ls --json
+```
+
+Discovery includes project configurations in the current directory and its
+parents, plus saved global workspaces. The first existing global directory
+wins, in this order:
+
+1. `TMUXP_CONFIGDIR`.
+2. `$XDG_CONFIG_HOME/tmuxp`, with [`~/.config`](#list-available-files) as the XDG default.
+3. [`~/.tmuxp`](#list-available-files).
+
+An existing empty directory remains selected. A missing directory does not
+override an existing fallback merely because its environment variable is set.
+
+## Search by content
+
+```console
+$ tmux-workspace search --json window:editor
+```
+
+Use [search](../../cli/search/) for field prefixes and pattern rules. Use
+[edit](../../cli/edit/) to open a discovered workspace, or
+[load](../../cli/load/) with an explicit path when a name is ambiguous.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/guides/export-session.md b/site/src/content/_workspace-shared/workspace/guides/export-session.md
index 84ba3b29..1e9bd877 100644
--- a/site/src/content/_workspace-shared/workspace/guides/export-session.md
+++ b/site/src/content/_workspace-shared/workspace/guides/export-session.md
@@ -1,5 +1,5 @@
 ---
-description: Capture, inspect, and replay a workspace without assuming lossless recovery.
+description: Capture a running session, inspect the document and load a second copy.
 product: workspace
 sidebar:
   group: Guides
@@ -9,10 +9,7 @@ tableOfContents: true
 title: Export and reload a session
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Use the session created by the [installation walkthrough](../installation/).
 Capture it to a new YAML destination:
 
@@ -54,8 +51,76 @@ $ tmux -L workspace-guide kill-session -t '=workspace-replay'
 
 The [freeze reference](../../cli/freeze/) explains prompts and overwrite
 behavior. [convert](../../cli/convert/) changes document representation without
-validating native execution support. The [native compatibility
-page](../../reference/compatibility/) records which ports lack capture or lose
-fields.
+validating whether a workspace can be loaded.
 
 [tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Capture the session created by the [installation walkthrough](../installation/)
+to a new YAML file:
+
+```console
+$ tmux-workspace freeze \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    --json \
+    --workspace-format yaml \
+    --save-to workspace-export.yaml \
+    workspace-guide
+```
+
+Review the saved commands, directories and layout. Capture reads current tmux
+state; it cannot recover original arguments, shell history, scripts, comments
+or application state. A captured command may need editing before replay.
+
+## Load a second copy
+
+Use a fresh session name on the same private server:
+
+```console
+$ tmux-workspace load \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    -d \
+    -s workspace-replayed \
+    --json \
+    workspace-export.yaml
+```
+
+Inspect the second copy's panes:
+
+```console
+$ tmux -S "$WORKSPACE_TMP/tmux.sock" list-panes -t '=workspace-replayed'
+```
+
+Remove that copy when finished:
+
+```console
+$ tmux -S "$WORKSPACE_TMP/tmux.sock" kill-session -t '=workspace-replayed'
+```
+
+[Capture](../../cli/freeze/) explains destination handling.
+[Conversion](../../cli/convert/) changes file encoding without proving the
+document can be loaded.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/guides/installation.md b/site/src/content/_workspace-shared/workspace/guides/installation.md
index 5de77305..1935b998 100644
--- a/site/src/content/_workspace-shared/workspace/guides/installation.md
+++ b/site/src/content/_workspace-shared/workspace/guides/installation.md
@@ -1,5 +1,5 @@
 ---
-description: Run the available Python workspace tool on a dedicated tmux socket.
+description: Build the workspace command and load a session on a private tmux socket.
 product: workspace
 sidebar:
   group: Guides
@@ -7,381 +7,400 @@ sidebar:
   order: 23
 tableOfContents: true
 title: Install and load a workspace
-ports:
-  ts:
-    description: Install the prerelease TypeScript workspace CLI from npm and load a session on a private tmux socket.
-  rs:
-    description: Build the local Rust workspace CLI and load a session on a private tmux socket.
-  go:
-    description: Build the local Go workspace CLI and load a session on a private tmux socket.
-  java:
-    description: Build the local Java workspace CLI and load a session on a private tmux socket.
-  dotnet:
-    description: Install the prerelease .NET workspace CLI from NuGet and load a session on a private tmux socket.
-  cxx:
-    description: Build the local C++ workspace CLI and load a session on a private tmux socket.
-  swift:
-    description: Build the local Swift workspace CLI and load a session on a private tmux socket.
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts -->Install and run the native TypeScript `tmux-workspace` command from its npm
-prerelease, `@libtmux/workspace-cli`. **This is a partial, prerelease
-implementation.**
-<!-- /port --><!-- port:rs -->Build and run the native Rust `tmux-workspace` command from the local
-<!-- /port --><!-- port:go -->Build and run the native Go `tmux-workspace` command from the local
-<!-- /port --><!-- port:java -->Build and run the native Java `tmux-workspace` command from the local
-<!-- /port --><!-- port:dotnet -->Install and run the native .NET `tmux-workspace` command from its NuGet
-prerelease, `LibTmux.Workspace.Cli`. **This is a partial, prerelease
-implementation.**
-<!-- /port --><!-- port:cxx -->Build and run the native C++ `tmux-workspace` command from the local
-<!-- /port --><!-- port:swift -->Build and run the native Swift `tmux-workspace` command from the local
-<!-- /port --><!-- port:rs,go,java,cxx,swift -->`workspace-cli` checkout. **This is a partial, unreleased implementation.**
-These commands require that local source; they are not registry installation
-instructions or a claim that the CLI is available on the published branch.
-<!-- /port -->
-<!-- port:py -->The runnable terminal loader is the separate Python application tmuxp. Its
+<!-- port:py -->
+The runnable terminal loader is the separate Python application tmuxp. Its
 documented prerequisites are Python 3.10 or newer and tmux 3.2 or newer. Install
 it in an isolated tool environment with uv:
-<!-- /port --><!-- port:rs,go,java,cxx,swift -->## Build from the local checkout
-
-Run these commands from the native repository root. Use a Unix environment
-with tmux 3.2a or newer on `PATH` for this walkthrough.
-
-<!-- /port --><!-- port:ts -->## Install from npm
-
-<!-- /port --><!-- port:dotnet -->## Install from NuGet
-
-<!-- /port --><!-- port:ts,dotnet -->Use a Unix environment with tmux 3.2a or newer on `PATH` for this walkthrough.
-
-<!-- /port --><!-- port:ts -->The command runs on Node.js 22.12 or newer, or Bun 1.3.14 or newer. Install
-it globally with npm:
-<!-- /port --><!-- port:rs -->Use Rust and Cargo through rustup so the checkout's
-[rust-toolchain.toml](https://github.com/libtmux/libtmux-rs/blob/master/rust-toolchain.toml)
-selects its pinned compiler. The full CLI minimum-toolchain and packaging gates
-remain open; the library's minimum Rust version is not a completed CLI guarantee.
-<!-- /port --><!-- port:go -->Use Go 1.26 or newer, as required by the checkout's
-[workspace module](https://github.com/libtmux/libtmux-go/blob/master/workspace/go.mod).
-Build from the repository root so its Go workspace selects the local modules.
-<!-- /port --><!-- port:java -->Use JDK 21 or newer and the repository's Gradle wrapper. The local
-application distribution includes its Java dependencies and needs Java on
-`PATH`, or `JAVA_HOME` set to a compatible JDK.
-<!-- /port --><!-- port:dotnet -->Installing needs the .NET SDK 8 or newer. The tool runs on the .NET 8 or
-.NET 10 runtime on Unix. For an SDK outside the platform's default
-installation location, set `DOTNET_ROOT` to that installation directory
-before running the tool.
-<!-- /port --><!-- port:cxx -->The development preset requires Clang 18.1.3 with libc++ 18.1, CMake 3.25 or
-newer, and Ninja. It builds C++23 and fetches pinned optional CLI dependencies.
-Core libtmux remains independent of CLI11, yaml-cpp and nlohmann JSON.
-<!-- /port --><!-- port:swift -->Use Swift 6.2 or newer on Linux. On macOS, use Xcode's Swift 6.3 or newer
-toolchain; the subprocess dependency requires it. The package targets macOS
-13 or newer. Enable the YAML build trait for this walkthrough; JSON-only
-builds can omit it.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-```console
-<!-- /port --><!-- port:ts -->$ npm install -g @libtmux/workspace-cli
-<!-- /port --><!-- port:rs -->$ cargo build \
-    --locked \
-    --package tmux-workspace \
-    --bin tmux-workspace \
-    --release \
-    --jobs 2
-<!-- /port --><!-- port:go -->$ GOMAXPROCS=2 go build \
-    -p 2 \
-    -o tmux-workspace \
-    ./workspace/cmd/tmux-workspace
-<!-- /port --><!-- port:java -->$ ./gradlew :workspace-cli:installDist \
-    --max-workers=2 \
-    --no-parallel
-<!-- /port --><!-- port:dotnet -->$ dotnet tool install \
-    --global \
-    --prerelease \
-    LibTmux.Workspace.Cli
-<!-- /port --><!-- port:cxx -->$ cmake --preset cxx-dev \
-    -DLIBTMUX_BUILD_WORKSPACE_CLI=ON
-<!-- /port --><!-- port:swift -->$ swift build \
-    --jobs 2 \
-    --traits YAMLWorkspaces \
-    --force-resolved-versions \
-    --product tmux-workspace
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->```
-
-<!-- /port --><!-- port:cxx -->```console
-$ cmake --build --preset cxx-dev \
-    --target tmux-workspace \
-    --parallel 2
-```
-
-<!-- /port --><!-- port:ts -->The package puts `tmux-workspace` on `PATH`. To run it without installing,
-use `npx -y @libtmux/workspace-cli` wherever this walkthrough runs
-`tmux-workspace`. The [overview](../../) lists the Bun, pnpm and Yarn runners
-and global installs.
-<!-- /port --><!-- port:rs -->The CLI feature is enabled by default in the local crate. This command
-builds its executable; installing the published library crate does not establish
-that this local CLI is available in a release.
-<!-- /port --><!-- port:go -->Ordinary search uses Go regular expressions. Python-only regex behavior is
-explicitly selected with `--regex-engine python`; it checks Python 3.10 or newer.
-Python shell and plugin/custom-builder execution require tmuxp 1.74.0.
-Plugin append uses the current session when the document has no `before_script`
-key. Native before-script arguments validate for all inputs before any session
-is created or changed.
-<!-- /port --><!-- port:java -->Keep the generated distribution together: its launcher uses libraries
-beside it. This local application distribution is separate from published
-Java library artifacts.
-<!-- /port --><!-- port:dotnet -->`--prerelease` is required: every release so far carries an `-alpha` tag,
-and NuGet skips those unless asked. A global tool installs into
-`~/.dotnet/tools`; add that directory to `PATH` if the SDK reports it
-missing.
-<!-- /port --><!-- port:cxx -->Use `load -d` for the detached workflow below. The CLI rejects unsupported
-legacy `-8` before file or backend access; `-2` selects 256-colour mode.
-Several other planned commands/options appear in help with explicit
-unavailable behavior.
-<!-- /port --><!-- port:swift -->Outside tmux, this local loader requires an explicit endpoint. The
-walkthrough supplies one with `-S`. A copied Linux executable still needs the
-Swift runtime libraries supplied by its toolchain; it is not a standalone
-distribution.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-Inspect the <!-- port:rs,go,java,cxx,swift -->built<!-- /port --><!-- port:ts,dotnet -->installed<!-- /port --> command:
-
-```console
-<!-- /port --><!-- port:ts -->$ tmux-workspace --help
-<!-- /port --><!-- port:rs -->$ target/release/tmux-workspace --help
-<!-- /port --><!-- port:go -->$ ./tmux-workspace --help
-<!-- /port --><!-- port:java -->$ workspace-cli/build/install/tmux-workspace/bin/tmux-workspace --help
-<!-- /port --><!-- port:dotnet -->$ tmux-workspace --help
-<!-- /port --><!-- port:cxx -->$ build/cxx-dev/apps/workspace/tmux-workspace --help
-<!-- /port --><!-- port:swift -->$ .build/debug/tmux-workspace --help
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->```
+```console
+$ uv tool install tmuxp
+```
+
+The tool environment owns tmuxp's Python dependencies, including libtmux.
 
 ## Create the input
 
-Keep this shell open for the walkthrough. Create a temporary directory for
-its configuration and private tmux socket:
+Save this file as [`workspace.yaml`](./#create-the-input) in a writable directory:
+
+```yaml
+session_name: workspace-guide
+windows:
+  - window_name: editor
+    layout: even-horizontal
+    panes:
+      - echo ready
+      - echo second
+```
+
+Load the session detached. Reserve the socket name for this walkthrough:
 
 ```console
-$ WORKSPACE_TMP="$(mktemp -d)"
+$ tmuxp load \
+    -L workspace-guide \
+    -d \
+    workspace.yaml
 ```
 
-Write a minimal configuration with two blank shell panes to
-[`workspace.yaml`](./#create-the-input) inside that directory:
+Inspect the two panes:
 
 ```console
-$ cat > "$WORKSPACE_TMP/workspace.yaml" <<'YAML'
-session_name: workspace-guide
-windows:
-  - window_name: editor
-    layout: even-horizontal
-    panes: [null, null]
-YAML
+$ tmux -L workspace-guide list-panes -t '=workspace-guide:editor'
 ```
 
-## Load and inspect
+Attach when ready:
 
-Load detached on the temporary socket. The JSON result describes the load;
-`-d` prevents terminal attachment:
+```console
+$ tmux -L workspace-guide attach-session -t '=workspace-guide'
+```
+
+Detach with your configured tmux detach binding. Before cleanup, optionally try
+[export and reload](../export-session/). Remove only this walkthrough's session
+when finished:
 
 ```console
-<!-- /port --><!-- port:ts -->$ tmux-workspace load \
-<!-- /port --><!-- port:rs -->$ target/release/tmux-workspace load \
-<!-- /port --><!-- port:go -->$ ./tmux-workspace load \
-<!-- /port --><!-- port:java -->$ workspace-cli/build/install/tmux-workspace/bin/tmux-workspace load \
-<!-- /port --><!-- port:dotnet -->$ tmux-workspace load \
-<!-- /port --><!-- port:cxx -->$ build/cxx-dev/apps/workspace/tmux-workspace load \
-<!-- /port --><!-- port:swift -->$ .build/debug/tmux-workspace load \
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->    -S "$WORKSPACE_TMP/tmux.sock" \
-    -d \
-    --json \
-    "$WORKSPACE_TMP/workspace.yaml"
+$ tmux -L workspace-guide kill-session -t '=workspace-guide'
 ```
+## Continue
+
+[Discovery](../discovery/) explains project files and saved names. [Configuration](../../configuration/) describes accepted fields, and [load](../../cli/load/) documents all flags.
+[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Build the documented `tmux-workspace` revision, then load a small session on a
+private socket. Use a Unix shell with tmux 3.2a or newer on `PATH`.
 
-Inspect the two panes through the same endpoint:
+## Build the command
 
+Fetch the documented source revision, then build from its repository root.
+Keep the exported `PATH` in this shell for the rest of the walkthrough.
+
+<!-- port:ts -->
 ```console
-$ tmux \
-    -S "$WORKSPACE_TMP/tmux.sock" \
-    list-panes \
-    -t '=workspace-guide:editor'
+$ git clone --filter=blob:none https://github.com/libtmux/libtmux-ts.git
 ```
 
-Attach with tmux when ready:
+```console
+$ cd libtmux-ts
+```
 
 ```console
-$ tmux \
-    -S "$WORKSPACE_TMP/tmux.sock" \
-    attach-session \
-    -t '=workspace-guide'
+$ git fetch --depth=1 origin f36d692552bb9a373b45338bb5fece854e57cc3d
 ```
 
-Detach with your configured tmux detach binding. Capture the live session
-without choosing a file destination:
+```console
+$ git checkout --detach FETCH_HEAD
+```
+
+Use Bun and Node.js 22 or newer. Install the locked dependencies and build the
+core package before the CLI:
 
 ```console
-<!-- /port --><!-- port:ts -->$ tmux-workspace freeze \
-<!-- /port --><!-- port:rs -->$ target/release/tmux-workspace freeze \
-<!-- /port --><!-- port:go -->$ ./tmux-workspace freeze \
-<!-- /port --><!-- port:java -->$ workspace-cli/build/install/tmux-workspace/bin/tmux-workspace freeze \
-<!-- /port --><!-- port:dotnet -->$ tmux-workspace freeze \
-<!-- /port --><!-- port:cxx -->$ build/cxx-dev/apps/workspace/tmux-workspace freeze \
-<!-- /port --><!-- port:swift -->$ .build/debug/tmux-workspace freeze \
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->    -S "$WORKSPACE_TMP/tmux.sock" \
-    --json \
-    workspace-guide
+$ bun install --frozen-lockfile
 ```
 
-Capture reports recoverable live state. It cannot reconstruct the original
-command history, script or plugin definitions. Remove the walkthrough session
-when finished:
+```console
+$ bun run --cwd packages/libtmux build
+```
 
 ```console
-$ tmux \
-    -S "$WORKSPACE_TMP/tmux.sock" \
-    kill-session \
-    -t '=workspace-guide'
-```
-
-The configuration remains in the temporary directory until you remove it.
-Every tmux command above addresses that private socket.
-
-## Current limits
-
-<!-- /port --><!-- port:ts -->Interactive prompts and complete configuration/platform acceptance remain
-unfinished. Capture reports live state rather than recovering the original
-workspace commands or extension intent.
-<!-- /port --><!-- port:rs -->Progress and logging controls, complete terminal attachment and interruption
-behavior, discovery/search edge cases, and the full configuration and platform
-corpus remain unfinished. Some accepted flags are compatibility targets rather
-than implemented behavior.
-<!-- /port --><!-- port:go -->Append through the Python workspace bridge with a document `before_script`
-key is unavailable and fails during preflight, including empty or null values.
-This prevents Python's script-failure cleanup from deleting the borrowed
-session. Native scripted append remains supported.
-<!-- /port --><!-- port:java -->Human load progress uses terminal stderr, with five presets or a custom
-`--progress-format` and a bounded `--progress-lines` panel. It preserves script
-stdout/stderr, clears on completion or interruption, and is disabled for machine
-output, redirected stderr, `TERM=dumb`, `--no-progress` or `TMUXP_PROGRESS=0`.
-<!-- /port --><!-- port:dotnet -->Native `--log-level` filters optional diagnostics. On Linux x64, human load
-displays progress on terminal stderr and `load --log-file` appends structured
-logs. See the [load reference](../../cli/load/#progress-and-script-output) and
-[output reference](../../reference/output/) for settings, resize and log-failure
-limits.
-<!-- /port --><!-- port:swift -->`load -2` forces 256-color handling in native tmux clients. Legacy `-8` is
-recognized but rejected before document lookup because supported tmux versions
-do not implement 88-color mode. Without `-2`, tmux detects color support.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,swift -->
-<!-- /port --><!-- port:ts -->Python shell evaluation and explicit plugin/custom-builder loads require an
-interpreter with tmuxp 1.74.0 installed. Select it with
-`TMUX_WORKSPACE_PYTHON`; the default is `python3`. Install extension packages in
-that interpreter or provide `workspace_builder_paths` relative to the workspace
-file. See [hooks and builders](../../configuration/hooks/) for append and failure
-behavior. Ordinary native loading of this example does not require Python.
-<!-- /port --><!-- port:go -->`load -s` changes only the final input's session name; earlier inputs keep
-their configured names. Legacy `-8` and `--88-colors` fail before workspace
-lookup or runtime checks. Use `-2` to request 256-color mode.
-<!-- /port --><!-- port:swift -->`--log-level` filters advisory diagnostics; fatal errors remain visible.
-`load --log-file` appends structured lifecycle and diagnostic records to a regular
-file. A write failure reports a secondary diagnostic and preserves the load result.
-<!-- /port --><!-- port:go,swift -->
-<!-- /port --><!-- port:go -->Some cleanup and interruption paths, diagnostic filtering, complete
-configuration coverage, and portable packaging still need work. Capture cannot
-reconstruct original command arguments, history or workspace extensions.
-<!-- /port --><!-- port:java -->Python plugins and custom builders execute through the checked tmuxp bridge.
-Extension append rejects documents containing `before_script` to preserve the
-borrowed session. Complete configuration/capture coverage and full
-terminal/platform acceptance remain unfinished. Progress uses the initial
-terminal dimensions; it does not track resizing, and Unicode clipping is
-conservative.
-<!-- /port --><!-- port:dotnet -->Human prompts and full terminal workflows, plugin and custom-builder
-validation, contextual completion, and the full configuration and platform
-corpus remain unfinished.
-<!-- /port --><!-- port:swift -->Human load displays progress on terminal stderr, with presets, custom counters
-and a bounded recent-output panel. It uses the initial terminal size and
-conservative Unicode clipping. Bootstrap output keeps its original stdout or
-stderr destination, but is collected before display. Machine output disables
-the panel and emits structured window/pane events. Interruption clears the
-panel; SIGINT and SIGTERM return status 130 and stop captured children.
-
-Terminal attachment, plugins/custom builders, further pane/window execution
-settings, fuller capture, generated manuals and portable distribution remain
-unfinished. The complete tmuxp flag surface is not available.
-<!-- /port --><!-- port:go,java,dotnet,swift -->
-<!-- /port --><!-- port:rs,go,java,dotnet,swift -->Python-specific shell behavior requires an interpreter with tmuxp 1.74.0
-installed. Select it with `TMUX_WORKSPACE_PYTHON`. Ordinary native loading of
-this example does not require Python.
-<!-- /port --><!-- port:cxx -->Python shell/plugin/custom-builder execution, full importer/configuration
-coverage and portable packaging remain unfinished. Native progress and
-[shell completion](../../cli/completion/#native-completion) are implemented;
-dynamic session/configuration-name suggestions remain unavailable.
-Native before scripts, terminal handoff and file logging are implemented; see
-[current coverage](../../reference/compatibility/) for their limits. Capture
-preserves local session/window options but omits inherited/global options and
-environment. It cannot recover original command arguments or history.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-## Python alternative
-
-For the separate released tmuxp application, install its isolated Python
-tool environment with uv:
+$ bun run --cwd packages/workspace-cli build
+```
+
+```console
+$ WORKSPACE_BIN="$(mktemp -d)"
+```
+
+```console
+$ ln -s "$PWD/packages/workspace-cli/dist/main.js" "$WORKSPACE_BIN/tmux-workspace"
+```
+
+```console
+$ export PATH="$WORKSPACE_BIN:$PATH"
+```
+
+The launcher runs the built JavaScript using Node. Keep the source directory
+in place while using it.
 <!-- /port -->
+<!-- port:rs -->
 ```console
-$ uv tool install tmuxp
+$ git clone --filter=blob:none https://github.com/libtmux/libtmux-rs.git
+```
+
+```console
+$ cd libtmux-rs
+```
+
+```console
+$ git fetch --depth=1 origin e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4
+```
+
+```console
+$ git checkout --detach FETCH_HEAD
+```
+
+Use the Rust toolchain selected by `rust-toolchain.toml`:
+
+```console
+$ cargo build --locked -p tmux-workspace --bin tmux-workspace
+```
+
+```console
+$ export PATH="$PWD/target/debug:$PATH"
+```
+<!-- /port -->
+<!-- port:go -->
+```console
+$ git clone --filter=blob:none https://github.com/libtmux/libtmux-go.git
+```
+
+```console
+$ cd libtmux-go
+```
+
+```console
+$ git fetch --depth=1 origin bb06e26e116e941813ca40bf45e7e3a47d38f52a
+```
+
+```console
+$ git checkout --detach FETCH_HEAD
+```
+
+Use Go 1.26 or newer. Building from the repository root selects its workspace
+modules:
+
+```console
+$ go build -o tmux-workspace ./workspace/cmd/tmux-workspace
+```
+
+```console
+$ export PATH="$PWD:$PATH"
+```
+<!-- /port -->
+<!-- port:java -->
+```console
+$ git clone --filter=blob:none https://github.com/libtmux/libtmux-java.git
+```
+
+```console
+$ cd libtmux-java
+```
+
+```console
+$ git fetch --depth=1 origin 3e5b20d22af3890ae5f7f52842e4b05d170a983f
+```
+
+```console
+$ git checkout --detach FETCH_HEAD
+```
+
+Use JDK 25 or newer and the repository's Gradle wrapper:
+
+```console
+$ ./gradlew --no-daemon --max-workers=2 :libtmux-workspace-cli:installDist
+```
+
+```console
+$ export PATH="$PWD/libtmux-workspace-cli/build/install/tmux-workspace/bin:$PATH"
+```
+
+Keep the distribution's `bin` and `lib` directories together. Set `JAVA_HOME`
+to the JDK if Java is not already on `PATH`.
+<!-- /port -->
+<!-- port:dotnet -->
+```console
+$ git clone --filter=blob:none https://github.com/libtmux/libtmux-dotnet.git
+```
+
+```console
+$ cd libtmux-dotnet
+```
+
+```console
+$ git fetch --depth=1 origin f77fe776ba67a04abb20ddbbc26cf4a000d63b74
+```
+
+```console
+$ git checkout --detach FETCH_HEAD
+```
+
+Use the .NET 10 SDK to build the command:
+
+```console
+$ dotnet build src/LibTmux.Workspace.Cli/LibTmux.Workspace.Cli.csproj --configuration Release
+```
+
+```console
+$ WORKSPACE_BIN="$(mktemp -d)"
+```
+
+```console
+$ ln -s "$PWD/src/LibTmux.Workspace.Cli/bin/Release/net10.0/LibTmux.Workspace.Cli" "$WORKSPACE_BIN/tmux-workspace"
+```
+
+```console
+$ export PATH="$WORKSPACE_BIN:$PATH"
+```
+
+Keep the build directory and the matching .NET runtime available when using
+this launcher.
+<!-- /port -->
+<!-- port:cxx -->
+```console
+$ git clone --filter=blob:none https://github.com/libtmux/libtmux-cxx.git
+```
+
+```console
+$ cd libtmux-cxx
+```
+
+```console
+$ git fetch --depth=1 origin 9c8c6a264114277df84c9f6819855093adae5c6e
+```
+
+```console
+$ git checkout --detach FETCH_HEAD
+```
+
+Use the compiler and CMake requirements in the repository's `cxx-dev` preset:
+
+```console
+$ cmake --preset cxx-dev \
+    -DLIBTMUX_BUILD_TESTS=OFF \
+    -DLIBTMUX_BUILD_EXAMPLES=OFF \
+    -DLIBTMUX_BUILD_MCP_SERVER=OFF
+```
+
+```console
+$ cmake --build --preset cxx-dev --target tmux-workspace -j2
+```
+
+```console
+$ export PATH="$PWD/build/cxx-dev/apps/workspace:$PATH"
+```
+<!-- /port -->
+<!-- port:swift -->
+```console
+$ git clone --filter=blob:none https://github.com/libtmux/libtmux-swift.git
+```
+
+```console
+$ cd libtmux-swift
+```
+
+```console
+$ git fetch --depth=1 origin 53c67947879f4976ddf2c43f3c8df7c7671c5b19
 ```
 
-<!-- port:py -->The tool environment owns tmuxp's Python dependencies. Installing a native
-libtmux workspace library does not install a tmuxp-compatible CLI.
+```console
+$ git checkout --detach FETCH_HEAD
+```
+
+Use Swift 6.2 and enable YAML decoding for this walkthrough:
+
+```console
+$ swift build --force-resolved-versions --traits YAMLWorkspaces --product tmux-workspace
+```
+
+```console
+$ export PATH="$PWD/.build/debug:$PATH"
+```
+
+A Linux executable still needs its Swift runtime libraries. Keep the matching
+toolchain available when running it.
+<!-- /port -->
+
+```console
+$ tmux-workspace --help
+```
 
 ## Create the input
 
-Save this file as [`workspace.yaml`](./#create-the-input) in a writable directory:
+Keep this shell open. Create a temporary working directory on a filesystem that
+supports Unix sockets, then enter it:
 
-```yaml
+```console
+$ WORKSPACE_TMP="$(mktemp -d)"
+```
+
+```console
+$ cd "$WORKSPACE_TMP"
+```
+
+Save this as `workspace.yaml`:
+
+```yaml title="workspace.yaml"
 session_name: workspace-guide
 windows:
   - window_name: editor
     layout: even-horizontal
-    panes:
-      - echo ready
-      - echo second
+    panes: [null, null]
 ```
 
-Load the session detached. Reserve the socket name for this walkthrough:
+## Load and inspect
 
 ```console
-$ tmuxp load \
-    -L workspace-guide \
+$ tmux-workspace load \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    -f /dev/null \
     -d \
+    --json \
     workspace.yaml
 ```
 
-Inspect the two panes:
+`-d` leaves the session detached. Inspect its panes using the same socket:
 
 ```console
-$ tmux -L workspace-guide list-panes -t '=workspace-guide:editor'
+$ tmux -S "$WORKSPACE_TMP/tmux.sock" list-panes -t '=workspace-guide:editor'
 ```
 
-Attach when ready:
+Attach interactively with `tmux -S "$WORKSPACE_TMP/tmux.sock" attach-session -t
+'=workspace-guide'`. Detach with your tmux detach binding before continuing.
+
+## Capture and clean up
 
 ```console
-$ tmux -L workspace-guide attach-session -t '=workspace-guide'
+$ tmux-workspace freeze -S "$WORKSPACE_TMP/tmux.sock" --json workspace-guide
 ```
 
-Detach with your configured tmux detach binding. Before cleanup, optionally try
-[export and reload](../export-session/). Remove only this walkthrough's session
-when finished:
+Try [export and reload](../export-session/) before cleanup. Capture cannot
+recover original scripts, command history or application state.
+
+Remove only the session created by this walkthrough when finished:
 
 ```console
-$ tmux -L workspace-guide kill-session -t '=workspace-guide'
+$ tmux -S "$WORKSPACE_TMP/tmux.sock" kill-session -t '=workspace-guide'
 ```
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->Follow the [Python installation guide](/py/latest/workspace/guides/installation/)
-for that workflow. Installing tmuxp does not install the native command.
-<!-- /port -->
+
+The configuration remains in the temporary directory. Keep the session running
+when following guides that continue this example.
+
 ## Continue
 
-<!-- port:py -->[Discovery](../discovery/) explains project files and saved names. [Configuration](../../configuration/) describes accepted fields, and [load](../../cli/load/) documents all flags. The [compatibility reference](../../reference/compatibility/) records native builder limitations.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->[Discovery](../discovery/), [configuration](../../configuration/) and the
-[load reference](../../cli/load/) explain the tmuxp compatibility model. Compare
-those references with the local command's help and the limits above.
-[Export and reload](../export-session/) explains the capture workflow, and the
-[compatibility reference](../../reference/compatibility/) records builder gaps.
-Use [Internals](../../internals/) for the library and consumer APIs.
+[Configuration](../../configuration/) describes execution fields;
+[discovery](../discovery/) finds saved files. Read the [load reference](../../cli/load/)
+and [automation](../automation/) for attachment, output and failure handling.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
 <!-- /port -->
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
diff --git a/site/src/content/_workspace-shared/workspace/guides/troubleshooting.md b/site/src/content/_workspace-shared/workspace/guides/troubleshooting.md
index e28fc17d..0cb945a5 100644
--- a/site/src/content/_workspace-shared/workspace/guides/troubleshooting.md
+++ b/site/src/content/_workspace-shared/workspace/guides/troubleshooting.md
@@ -1,18 +1,15 @@
 ---
-description: Diagnose argument, discovery, configuration, shell, and partial-build failures.
+description: Find the failed stage before retrying a workspace operation.
 product: workspace
 sidebar:
   group: Guides
-  label: Troubleshoot workspace loading
+  label: Troubleshoot a workspace
   order: 27
 tableOfContents: true
-title: Troubleshoot workspace loading
+title: Troubleshoot a workspace
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../../reference/compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+<!-- port:py -->
 Start by identifying the failing stage. A parser error happens before a
 workspace is loaded. A missing file is a discovery problem. An accepted document
 can still fail during tmux creation, shell startup, command dispatch, or a
@@ -49,10 +46,74 @@ endpoint when inspecting a failed load. A partial build can leave sessions,
 windows, and panes behind; inspect them before cleanup. Do not assume rollback
 or kill an unrelated default server.
 
-Native failures must be evaluated against [port
-compatibility](../../reference/compatibility/), not inferred from a Python
-<!-- port:py -->example. The proposed machine contract reports completed and failed stages
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->example. The native machine contract reports completed and failed stages
-<!-- /port -->explicitly.
-
 [tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Start with the error message and exit status. A partially completed load can
+leave sessions or windows running; inspect its result before retrying or
+cleaning up.
+
+## Confirm the command and input
+
+```console
+$ tmux-workspace debug-info --json
+```
+
+Check the executable version, selected tmux binary and workspace directories.
+Use an explicit file path to bypass saved-name lookup. Verify the socket matches
+the one used for inspection and capture.
+
+## Common failures
+
+| Symptom | Next check |
+| --- | --- |
+| Workspace not found | Explicit path, file extension and global discovery directory |
+| Unsupported field | CLI configuration fields and the reported field path |
+| tmux unavailable | Executable path, permissions and selected socket |
+| Existing session mismatch | Running window names and the requested document |
+| Layout rejected | Layout name, pane capacity and the selected tmux version |
+| File already exists | Select a new output path or authorize replacement with `--force` |
+| Script failed | Child status, captured output and working directory |
+| Interactive context required | Use `load -d` for automation; provide a terminal for interactive work |
+
+## Record a load
+
+Continue the [installation walkthrough](../installation/) and append diagnostic
+records to a local file:
+
+```console
+$ tmux-workspace --log-level debug load \
+    -S "$WORKSPACE_TMP/tmux.sock" \
+    -d \
+    --json \
+    --log-file workspace-load.log \
+    workspace.yaml
+```
+
+Logs may include script output and local paths. Inspect them before sharing a
+bug report. Include the command, versions, minimal configuration, exit status
+and relevant result; remove private values.
+
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/index.md b/site/src/content/_workspace-shared/workspace/index.md
index 79502e5b..5b5d4e4e 100644
--- a/site/src/content/_workspace-shared/workspace/index.md
+++ b/site/src/content/_workspace-shared/workspace/index.md
@@ -1,15 +1,32 @@
 ---
-title: "tmux workspace manager overview"
-description: "Workspace manager overview."
+title: Workspace manager
+description: Describe a tmux session in a file, then load, inspect and capture it.
 product: workspace
+ports:
+  py:
+    title: Python workspace manager
+  ts:
+    title: TypeScript workspace manager
+  rs:
+    title: Rust workspace manager
+  go:
+    title: Go workspace manager
+  java:
+    title: Java workspace manager
+  dotnet:
+    title: .NET workspace manager
+  cxx:
+    title: C++ workspace manager
+  swift:
+    title: Swift workspace manager
 sidebar:
-  label: Overview
+  label: Workspace manager
   order: 0
 tableOfContents: true
 cards:
   - label: Command reference
     href: ./cli/
-    body: Every command, flag and compatibility target.
+    body: Commands, options and machine output.
   - label: Configuration
     href: ./configuration/
     body: Workspace fields, normalization and execution.
@@ -19,328 +36,87 @@ cards:
   - label: Example gallery
     href: ./examples/gallery/
     body: Workspace files to start from, with their prerequisites.
-  - label: Compatibility
+  - label: Runtime support
     href: ./reference/compatibility/
-    body: What is implemented, and where it differs from tmuxp.
+    body: Runtime requirements and supported behavior.
   - label: Internals
     href: ./internals/
     body: The workspace library, for building sessions from code.
-ports:
-  py:
-    title: "tmux workspace manager for Python"
-    description: "Create, load, and export tmux workspaces with tmuxp."
-  ts:
-    title: "tmux workspace manager for TypeScript"
-    description: "Run or install the prerelease TypeScript tmux-workspace CLI from npm; implementation coverage remains partial."
-  rs:
-    title: "tmux workspace manager for Rust"
-    description: "Build the local Rust tmux-workspace CLI; implementation coverage remains partial and unreleased."
-  go:
-    title: "tmux workspace manager for Go"
-    description: "Build the local Go tmux-workspace CLI; implementation coverage remains partial and unreleased."
-  java:
-    title: "tmux workspace manager for Java"
-    description: "Build the local Java tmux-workspace CLI; implementation coverage remains partial and unreleased."
-  dotnet:
-    title: "tmux workspace manager for .NET"
-    description: "Install the prerelease .NET tmux-workspace CLI from NuGet; implementation coverage remains partial."
-  cxx:
-    title: "tmux workspace manager for C++"
-    description: "Build the local C++ tmux-workspace CLI; implementation coverage remains partial and unreleased."
-  swift:
-    title: "tmux workspace manager for Swift"
-    description: "Build the local Swift tmux-workspace CLI; implementation coverage remains partial and unreleased."
 ---
-<!-- port:py -->
-[tmuxp](https://tmuxp.git-pull.com/) is Python's workspace manager built on
-libtmux. A YAML or JSON file describes a session, its windows and panes, and
-the commands to run. `tmuxp load` builds that workspace and can attach you to
-it or leave it detached.
 
-The application also finds saved workspaces, exports a running session,
-converts configuration formats, and supports Python plugins and custom
-workspace builders.
+<!-- port:py -->
+[tmuxp](https://tmuxp.git-pull.com/) loads tmux sessions from YAML or JSON using
+libtmux. A file describes windows, panes and commands. `tmuxp load` builds the
+session and can attach to it or leave it detached.
 
 ## Start here
 
-- [Guides](./guides/) install tmuxp and load a workspace on a dedicated socket.
-- [Topics](./topics/) explain configuration, existing sessions, and exports.
-- [Examples](./examples/) load YAML and JSON through the CLI.
-- [Internals](./internals/) describe the builder pipeline and Python APIs for
-  contributors and extension authors.
+1. [Install tmuxp and load a workspace](./guides/installation/).
+2. [Configure windows and panes](./configuration/).
+3. [Capture and reload a session](./guides/export-session/).
 
-## Package and documentation
+The [command reference](./cli/) covers discovery, search, editing, conversion
+and import. Use [examples](./examples/gallery/) for complete files and their
+prerequisites.
 
-Install `tmuxp` separately from the core `libtmux` package. Let its dependency
-resolver choose a compatible libtmux version. The MCP server is another
-application with its own requirements, so use separate tool environments when
-their dependency ranges differ.
+Install tmuxp separately from the core libtmux package. Its dependency resolver
+selects a compatible libtmux release. [Workspace internals](./internals/)
+describe the builder and Python extension APIs.
 
-The [tmuxp documentation](https://tmuxp.git-pull.com/) provides the complete
-upstream CLI reference, workspace format, and extension documentation.
+[Quickstart source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/docs/quickstart.md).
+<!-- /port -->
 
-[Upstream quickstart source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/docs/quickstart.md)
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+`tmux-workspace` creates tmux sessions from YAML or JSON. A file describes
+windows, panes, commands, directories and environment. Load it from a terminal
+or request machine output for automation.
 
-## tmuxp command and configuration reference
+## Load a workspace from the terminal
 
-The Python command pages document the current tmuxp reference and label proposed native extensions.
+1. [Install the command and load a workspace](./guides/installation/).
+2. [Configure windows and panes](./configuration/).
+3. [Capture and reload a session](./guides/export-session/).
 
-- [Installation walkthrough](./guides/installation/) uses the available Python tool.
-- [Command reference](./cli/) lists commands, flags, and observed behavior.
-- [Configuration](./configuration/) covers fields, normalization, and execution.
-- [Example gallery](./examples/gallery/) includes upstream fixtures and prerequisites.
-- [Compatibility status](./reference/compatibility/) records native builder gaps.
-- [JSON, NDJSON, and color](./reference/output/) defines the proposed native output contract.
-<!-- /port -->
-<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-<!-- port:ts -->
-Native services load/reuse/append and capture sessions, discover and search
-documents, convert formats, import configurations and run editors. Loading
-includes terminal attach/switch, before scripts, progress and diagnostics.
-Python shell evaluation and explicit plugin/custom-builder loads use an optional
-tmuxp bridge. Ordinary native loads do not start Python. Native command metadata
-and Bash, Zsh and fish completion come from the parser; completion starts no
-Node, Bun or tmux process.
-<!-- /port -->
-<!-- port:rs -->
-Native services load and capture sessions, discover and search documents,
-convert formats, import tmuxinator/teamocil files, and run editors. Python
-shells and workspace extensions use an explicit version-checked bridge.
-Append validates the current daemon and retains the borrowed session across
-inputs.
-<!-- /port -->
-<!-- port:go -->
-Native services provide load/reuse/append, capture, discovery, conversion,
-imports, editor execution and search. Loading supports common commands,
-directories, environment, options, before scripts and terminal progress.
-Native script arguments validate for all inputs before session mutation.
-Append authenticates the inherited server and retains one target session across
-all inputs. Plugin and custom-builder append use that session through the
-checked Python bridge when the document has no `before_script` key.
-<!-- /port -->
-<!-- port:java -->
-Native services load and capture sessions, discover and search documents,
-convert formats, import configurations and run editors. Common commands,
-layout, environment, before scripts and diagnostics are implemented. Python
-shell evaluation and plugin/custom-builder loading use a checked tmuxp bridge.
-Human load progress supports
-presets, custom templates and a bounded script-output panel. Append keeps its
-original target session across input files.
-<!-- /port -->
-<!-- port:dotnet -->
-Native services load/reuse/append and capture sessions, discover and search
-documents, convert formats, import configurations and run editors. A checked
-Python bridge provides Python-specific shell and workspace-extension behavior.
-<!-- /port -->
-<!-- port:cxx -->
-Native services load and attach sessions, reuse exact names, append windows,
-capture topology, discover and search documents, convert formats, import
-configurations and run editors. Ordinary search uses C++ regular expressions.
-<!-- /port -->
-<!-- port:swift -->
-Native services discover, search, convert, import, edit, load, append and
-capture workspaces. Common directories, command inheritance,
-indexes, focus, session environment/options and before scripts are supported.
-Python shell evaluation uses a checked tmuxp bridge.
+The [command reference](./cli/) covers discovery, search, editing, loading,
+capture, conversion and import. [Examples](./examples/gallery/) provide
+complete configurations with their prerequisites.
 
-`load -2` forces 256-color handling in native tmux clients. Legacy `-8` is
-recognized but rejected before document lookup because supported tmux versions
-do not implement 88-color mode. Without `-2`, tmux detects color support.
-<!-- /port -->
+## Automate and inspect
 
-## Load a workspace from the terminal
+Use `load -d` when the caller should return without attaching. `--json` returns
+a result, and `--ndjson` supports a stream of records. Read
+[automation](./guides/automation/) for retry and cleanup decisions and
+[errors](./reference/exit-codes/) for failure handling.
 
-<!-- port:rs,go,java,cxx,swift -->Follow the [local installation walkthrough](./guides/installation/) from a
-`workspace-cli` checkout of the
-<!-- port:rs -->[Rust repository](https://github.com/libtmux/libtmux-rs)<!-- /port --><!-- port:go -->[Go repository](https://github.com/libtmux/libtmux-go)<!-- /port --><!-- port:java -->[Java repository](https://github.com/libtmux/libtmux-java)<!-- /port --><!-- port:cxx -->[C++ repository](https://github.com/libtmux/libtmux-cxx)<!-- /port --><!-- port:swift -->[Swift repository](https://github.com/libtmux/libtmux-swift)<!-- /port -->. It builds
-the native command and loads a small workspace on a private socket. After
-building, inspect the command without starting tmux:
-<!-- /port --><!-- port:ts -->[Install](#install) runs the `@libtmux/workspace-cli` prerelease from npm
-without installing it, or installs it to put `tmux-workspace` on `PATH`. The
-[installation walkthrough](./guides/installation/) loads a small workspace on
-a private socket. Inspect the command without starting tmux:
-<!-- /port --><!-- port:dotnet -->Install `tmux-workspace` from NuGet with any method under
-[Install](#install). The [installation walkthrough](./guides/installation/)
-loads a small workspace on a private socket. Inspect the command without
-starting tmux:
-<!-- /port -->
-```console
-<!-- port:ts -->$ npx -y @libtmux/workspace-cli --help<!-- /port --><!-- port:rs -->$ target/release/tmux-workspace --help<!-- /port --><!-- port:go -->$ ./tmux-workspace --help<!-- /port --><!-- port:java -->$ workspace-cli/build/install/tmux-workspace/bin/tmux-workspace --help<!-- /port --><!-- port:dotnet -->$ tmux-workspace --help<!-- /port --><!-- port:cxx -->$ build/cxx-dev/apps/workspace/tmux-workspace --help<!-- /port --><!-- port:swift -->$ .build/debug/tmux-workspace --help<!-- /port -->
-```
+Loaded workspaces are ordinary tmux sessions. Select the same socket when
+inspecting them from tmux or the [MCP server](../mcp/).
 
-Use detached load for the walkthrough. JSON and NDJSON output are available;
-choose the mode explicitly when scripting. The command/configuration reference
-below also documents tmuxp behavior and compatibility targets, so it is not a
-claim that every referenced feature works in this <!-- port:rs,go,java,cxx,swift -->local <!-- /port -->implementation.
+## Build from application code
 
-## Current coverage
-<!-- port:ts -->
+The [workspace library](./internals/) has its own API and configuration
+contract. Use it when a program needs direct control over construction. The
+CLI task guides here describe the `tmux-workspace` executable and link to its
+documented source revision.
 
-Interactive prompts and complete configuration/platform acceptance remain
-unfinished. Python extensions require tmuxp 1.74.0 and report observed effects
-without claiming ownership or rollback. See [hooks and builders](./configuration/hooks/)
-for append restrictions. Capture reports live state rather than recovering the
-original workspace commands or extension intent.
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
 <!-- /port -->
 <!-- port:rs -->
-
-Native load supports [filtered file logging](./reference/output/#native-rust-logging).
-
-Human load supports progress templates and bounded script lines. Attachment
-checks the terminal and invoking client before mutation. SIGINT and SIGTERM
-report completed inputs and acknowledged effects; interruption does not roll
-them back. Human bootstrap scripts retain terminal stdin with foreground and
-terminal-setting restoration on supported targets.
-
-Human listing supports tree and full views with escaped labels. Native
-generation exports command metadata, manuals and completion scripts without
-starting tmux or Python. Discovery/search edge cases, complete configuration
-coverage and broader platform lifecycle validation remain open. See the
-[compatibility reference](./reference/compatibility/) for cancellation and
-platform limits.
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
 <!-- /port -->
 <!-- port:go -->
-
-Append through the Python workspace bridge with a document `before_script`
-key is unavailable and fails during preflight, including empty or null values.
-This prevents Python's script-failure cleanup from deleting the borrowed
-session. Native scripted append remains supported.
-
-`load -s` changes only the final input's session name; earlier inputs keep
-their configured names. Legacy `-8` and `--88-colors` fail before workspace
-lookup or runtime checks. Use `-2` to request 256-color mode.
-
-Native Go logging supports `--log-level` and structured `--log-file` output
-on Unix. Diagnostic filtering preserves mandatory command errors and machine
-results. See the [logging contract](./reference/output/#native-go-logging).
-
-Some cleanup and interruption paths, complete configuration coverage, and
-portable packaging still need work. Capture cannot
-reconstruct original command arguments, history or workspace extensions.
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
 <!-- /port -->
 <!-- port:java -->
-
-Python plugins and custom builders execute through the checked tmuxp bridge.
-Extension append rejects documents containing `before_script` to preserve the
-borrowed session. Complete configuration/capture coverage and full
-terminal/platform acceptance remain unfinished. Progress uses the initial
-terminal dimensions; it does not track resizing, and Unicode clipping is
-conservative.
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
 <!-- /port -->
 <!-- port:dotnet -->
-
-Native [imports](./cli/import/#native-net-imports) preserve supported command
-groups, directories, Teamocil options/focus and synchronization timing. They
-validate the translated workspace before printing or saving it and refuse
-unsupported lifecycle fields. Load creates panes in configuration order;
-[pane configuration](./configuration/panes/) explains indexes and focus.
-
-Native `--log-level` filters optional diagnostics. On Linux x64,
-`load --log-file` appends structured logs; see the
-[output reference](./reference/output/) for destination and failure handling.
-
-On Linux x64, human load shows terminal progress on stderr, with presets,
-literal token templates and bounded script output. See
-[load](./cli/load/#progress-and-script-output) for counters, stream handling
-and resize limits.
-
-Native append retains the current pane's resolved session across all inputs,
-even if a script moves the pane. Later commands reject a replacement daemon.
-Append with Python plugins or custom builders is unavailable and fails before
-building any input or starting Python; use `-d` for those extensions.
-
-Human load supports attachment and client-selection prompts from a foreground
-controlling terminal on Linux x64. It authenticates the invoking pane and
-selected daemon before building, then checks the client again before handoff.
-See [native attachment](./cli/load/#native-net-attachment) for choices and
-interruption behavior.
-
-Attached Python extension handoff, broader extension lifecycle validation,
-contextual completion, and the full configuration and platform corpus remain
-unfinished.
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
 <!-- /port -->
 <!-- port:cxx -->
-
-`before_script` runs a quoted command directly after session creation or append
-selection, before settings and windows. All inputs are validated first. Script
-failure removes a newly owned session and preserves a borrowed append session;
-NDJSON streams script output while the child runs.
-
-Human load requires a foreground terminal. It attaches outside tmux or switches
-the unique terminal client viewing the invoking pane. The final input selects
-the session, including reuse. Output is flushed before handoff; failures retain
-loaded changes. See [loading and attachment](./cli/load/#native-c-loading).
-
-Independent `active-pane` focus on the invoking physical window requires `-d`
-or `--append`, including linked windows.
-
-`load --log-file PATH` appends JSON diagnostics. Log levels filter optional
-records without hiding required errors or changing machine results. See
-[logging](./reference/output/#native-c-logging) for file and failure behavior.
-
-Human load has terminal progress with presets, templates and bounded script
-output. Native Bash, Zsh and Fish completion covers commands, flags, choices
-and paths. Dynamic session/configuration-name suggestions remain unavailable.
-
-Human `ls --tree` groups workspaces by directory; `--full` includes parsed
-configuration. The optional [shell](./cli/shell/#native-execution) uses an
-installed tmuxp 1.74.0 executable, with streaming and terminal restoration.
-Native loading remains independent of Python.
-
-Plugin/custom-builder execution, full importer/configuration
-coverage and portable packaging remain unfinished. Capture preserves local
-session/window options but omits inherited/global options and environment.
-It cannot recover original command arguments or history.
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
 <!-- /port -->
 <!-- port:swift -->
-
-`--log-level` filters advisory diagnostics; fatal errors remain visible.
-`load --log-file` appends structured lifecycle and diagnostic records to a regular
-file. A write failure reports a secondary diagnostic and preserves the load result.
-
-Human load displays progress on terminal stderr, with presets, custom counters
-and a bounded recent-output panel. It uses the initial terminal size and
-conservative Unicode clipping. Bootstrap output streams to its original stdout
-or stderr destination and updates the panel while the script runs. Machine
-output disables the panel and sends child text as structured stderr warnings;
-load events remain on stdout. See the [child output contract](./reference/output/#native-swift-child-output)
-for limits and cancellation behavior.
-
-Human load with a foreground terminal attaches to the final workspace. Inside
-tmux, choose switch, detached load, append or cancel. `-y` skips the mode prompt
-and refuses an ambiguous client selection. Redirected and machine calls require
-`-d` or `--append`. Detaching or interrupting the client preserves loaded sessions.
-
-Plugins/custom builders, further pane/window execution
-settings, fuller capture, generated manuals and portable distribution remain
-unfinished. Parser coverage does not establish support for every configuration
-field or execution path.
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
 <!-- /port -->
-
-For the released Python workflow, use [tmuxp](https://tmuxp.git-pull.com/)
-and its [Python workspace guide](/py/latest/workspace/guides/). It is a separate
-application and remains useful when a required native feature is incomplete.
-
-## Start here
-
-<!-- port:ts -->The `@libtmux/workspace` library package<!-- /port --><!-- port:rs -->The `tmux-workspace` library crate<!-- /port --><!-- port:go -->The `workspace` library module<!-- /port --><!-- port:java -->The `libtmux-workspace` library module<!-- /port --><!-- port:dotnet -->The `LibTmux.Workspace` library package<!-- /port --><!-- port:cxx -->The `workspace_builder` source consumer<!-- /port --><!-- port:swift -->The `TmuxWorkspace` SwiftPM library product<!-- /port --> remains available for applications that
-build sessions through code. [Internals](./internals/) documents that API:
-
-- [Guides](./internals/guides/) show application setup and builder calls.
-- [Topics](./internals/topics/) explain supported configuration and behavior.
-- [Examples](./internals/examples/) exercise the library or source consumer.
-- [API](./reference/) covers the builder and configuration interfaces.
-
-## tmuxp command and configuration reference
-
-Use the <!-- port:rs,go,java,cxx,swift -->local <!-- /port -->CLI's help and the limits above when applying these compatibility
-references to native execution.
-
-- [Installation walkthrough](./guides/installation/) <!-- port:rs,go,java,cxx,swift -->builds and runs the local native CLI.<!-- /port --><!-- port:ts,dotnet -->installs and runs the published native CLI.<!-- /port -->
-- [Inspect through MCP](./guides/inspect-with-mcp/) connects to the loaded session.
-- [Command reference](./cli/) lists tmuxp commands, flags and compatibility targets.
-- [Configuration](./configuration/) covers fields, normalization and execution.
-- [Example gallery](./examples/gallery/) includes upstream fixtures and prerequisites.
-- [Compatibility status](./reference/compatibility/) records builder/reference gaps.
-- [JSON, NDJSON, and color](./reference/output/) describes the shared output design.
 <!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/internals/documentation.md b/site/src/content/_workspace-shared/workspace/internals/documentation.md
index 3331aec1..9b9a0ebe 100644
--- a/site/src/content/_workspace-shared/workspace/internals/documentation.md
+++ b/site/src/content/_workspace-shared/workspace/internals/documentation.md
@@ -1,94 +1,92 @@
 ---
-description: Keep help, completion, and site references aligned with command metadata.
+description: Generate command references from the parser and verify task examples against the CLI.
 product: workspace
 sidebar:
   group: Internals
-  label: Documentation
+  label: Workspace reference generation
   order: 80
 tableOfContents: true
 title: Workspace reference generation
 ---
 
-<!-- port:py -->This page describes the documentation integration for Python. Native CLI
-<!-- /port --><!-- port:dotnet -->This page describes the documentation integration for .NET. Native CLI
-<!-- /port --><!-- port:py,dotnet -->references remain compatibility targets until an installed command exists.
-<!-- /port --><!-- port:ts -->The native TypeScript CLI derives help and exports from its parser definitions.
-<!-- /port --><!-- port:rs -->The native Rust CLI derives help and exports from its parser definitions.
-<!-- /port --><!-- port:go -->The native Go CLI derives help and exports from its parser definitions.
-<!-- /port --><!-- port:java -->The native Java CLI derives help and exports from its parser definitions.
-<!-- /port --><!-- port:cxx -->The native C++ CLI derives help and exports from its parser definitions.
-<!-- /port --><!-- port:swift -->The native Swift CLI derives help and exports from its parser definitions.
-<!-- /port --><!-- port:ts,rs,go,java,cxx,swift -->[Compatibility](../../reference/compatibility/) records current coverage.
+<!-- port:py -->
+tmuxp uses argparse definitions from `tmuxp.cli.create_parser` for its command
+reference. The optional `shtab` integration reads that parser for completion.
+
+## Keep syntax and behavior aligned
+
+Preserve required and mutually exclusive groups when exporting parser metadata.
+An optional-looking positional in help can still belong to a required group.
+Run examples against the corresponding tmuxp revision, including prompts,
+machine formats, child failures and cleanup.
+
+The CLI reference and [workspace builder API](../../internals/) serve different
+tasks. Keep their example imports, prerequisites and behavior explicit.
+
+[Parser source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
 <!-- /port -->
+
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+The executable's parser owns its command names, arguments and options. Keep
+reference generation tied to those definitions.
+
 ## Command metadata
 
-<!-- port:py -->tmuxp uses argparse metadata from create_parser for its upstream Sphinx CLI reference. Its separately installed shtab integration consumes that parser for completion. The documentation adapter must preserve required groups rather than infer arity from optional-looking help.
-<!-- /port --><!-- port:ts -->Commander defines the native command graph. The CLI package generates Markdown,
-a JSON command catalog, and Bash, Zsh, and Fish completion from those definitions.
-`docs:check` compares generated files in CI. Keep option event order when paired
-flags share a destination.
-<!-- /port --><!-- port:rs -->Clap defines the native command graph. `--generate schema` exports metadata;
-`--generate man` renders the root manual. `--generate` also accepts `bash`, `zsh`,
-`fish`, `powershell`, and `elvish` through clap_complete. Separate subcommand
-manuals are not generated.
-<!-- /port --><!-- port:go -->Cobra defines the native command graph. `--command-tree` exports JSON metadata;
-`--generate-docs` accepts `markdown`, `man`, or `yaml`.
-`--generate-completion` accepts `bash`, `zsh`, `fish`, or `powershell`. Exports
-distinguish command-local flags from inherited machine-output options.
-<!-- /port --><!-- port:java -->Picocli defines the native command graph. `--generate schema` exports metadata
-and `--generate bash` emits completion through its code generator. Other manual
-and completion formats are not exposed by the workspace executable.
-<!-- /port --><!-- port:py,ts,rs,go,java -->
-<!-- /port --><!-- port:py -->The [command reference](../../cli/) covers the Python grammar. A future native
-export must record command paths, aliases, positional arity, option spellings,
-<!-- /port --><!-- port:java -->Bash generation also supports a JSON artifact or one completed NDJSON event;
-the script remains a string inside the machine result. Schema generation keeps
-its metadata document. See [machine completion output](../../cli/completion/).
-<!-- /port --><!-- port:dotnet -->System.CommandLine defines the native command graph. `--generate reference`
-exports its metadata; `--generate man`, `bash`, `zsh`, and `fish` render the other
-formats. The completion scripts offer command and option names without full
-argument context. Spectre.Console owns human presentation separately.
-<!-- /port --><!-- port:cxx -->CLI11 defines the native command graph. Its filtered `get_subcommands` overload
-enumerates command definitions; the unfiltered overload describes parsed commands.
-A site exporter and shell completion remain unimplemented.
-<!-- /port --><!-- port:swift -->ArgumentParser defines the native command graph and supplies
-`--generate-completion-script` for shell completion. Manual, DocC, and site
-metadata integration remain separate work. Use supported parser APIs for those
-exports; private parser reflection is not a stable contract.
-<!-- /port --><!-- port:java,dotnet,cxx,swift -->
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->The [command reference](../../cli/) covers the Python grammar. Native metadata
-exports need to record command paths, aliases, positional arity, option spellings,
-<!-- /port -->types, defaults, choices, required and exclusive groups, store-constant values,
-repeat and ordering behavior, environment bindings, and child commands. Output
-schemas and availability belong alongside that metadata.
+<!-- port:ts -->
+Commander owns the command definitions. The package generates Markdown, a JSON command catalog and completion scripts from those definitions. `docs:check` checks their freshness.
+<!-- /port -->
+<!-- port:rs -->
+clap owns the command definitions. `--generate schema` exports command metadata, `--generate man` writes the manual, and completion generation uses the same graph.
+<!-- /port -->
+<!-- port:go -->
+Cobra owns the command tree. `--command-tree` exports JSON metadata; `--generate-docs` accepts `markdown`, `man` or `yaml`.
+<!-- /port -->
+<!-- port:java -->
+picocli owns the command definitions. `--generate schema` exports metadata and `--generate bash` writes completion.
+<!-- /port -->
+<!-- port:dotnet -->
+System.CommandLine owns the command definitions. `--generate reference` exports metadata; `--generate man` writes the manual.
+<!-- /port -->
+<!-- port:cxx -->
+CLI11 owns the command definitions. The CLI derives shell completion from that graph. The site task guides describe executable operations separately from the workspace library API.
+<!-- /port -->
+<!-- port:swift -->
+ArgumentParser owns the command definitions and `--generate-completion-script` generates shell completion. The site task guides describe executable operations separately from the workspace library API.
+<!-- /port -->
 
-Generate help, completion, and static reference from the same definitions.
-Compare generated results in CI and test actual installed help separately.
-A rendered example or successful parser-only probe does not establish service
-execution, distribution, or tmux compatibility.
 
-## Site integration
+See [shell completion](../../cli/completion/) for end-user setup. A generated
+parser reference describes syntax; task examples also need to exercise the
+underlying services and their cleanup.
 
-Keep equivalent task pages at the same workspace path in every port. The
-existing page switcher offers authored counterparts and leaves absent pages
-unavailable. A CLI guide and a builder API guide are different counterparts;
-preserve [builder reference](../../reference/) as its own surface.
+## Site integration
 
-Write executable shell examples per port. Shared console, YAML, and JSON blocks
-survive language filtering. Installing a native library must not be presented
-as installing a workspace executable when it has no such artifact.
+Record the CLI's own source revision independently from the core library
+reference. Keep commands, configuration and examples specific to that source.
+Use the same content selection for HTML, search, Markdown and machine exports.
 
-The site version and workspace package version can differ. Record the package
-and source revision independently, and do not use an older version-shaped URL
-<!-- port:py -->to imply that today's command existed in an older release. This local research
-prototype is reviewed against current source.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->to imply that today's command existed in an older release. The installation
-guide identifies the available source builds and published artifacts.
-<!-- /port -->
-## Verification
+Verify guides against a private tmux server, with cleanup limited to the objects
+the test owns. Check failure cases as well as successful construction.
 
-Check [configuration](../../configuration/), [machine output](../../reference/output/),
-and [compatibility](../../reference/compatibility/) together. Exercise equivalent
-page paths, API backlinks, fragments, sidebars, metadata exports, search, and
-preview prefixes in assembled output. Verify command examples against isolated
-tmux servers, with explicit cleanup and known limitations.
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/reference/exit-codes.md b/site/src/content/_workspace-shared/workspace/reference/exit-codes.md
index 3ba5ad63..897f6c8c 100644
--- a/site/src/content/_workspace-shared/workspace/reference/exit-codes.md
+++ b/site/src/content/_workspace-shared/workspace/reference/exit-codes.md
@@ -1,78 +1,96 @@
 ---
-title: "Exit codes and errors"
-description: "Observed Python exit behavior and the proposed native error contract."
+title: Exit codes and errors
+description: Use process status and structured error codes to handle workspace failures.
 product: workspace
 sidebar:
-  label: "Exit codes and errors"
+  label: Exit codes and errors
   group: "Reference"
   order: 28
 tableOfContents: true
 ---
+
 <!-- port:py -->
-This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port -->
-<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
-**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../compatibility/) describes this port's implemented coverage.
-<!-- /port -->
+tmuxp generally uses `0` for success, `1` for operation failures and `2` for
+argument errors. Some commands have exceptions at this documented revision.
 
-Python tmuxp uses 0 for success, 1 for general failures, and 2 for argument
-usage errors. Those categories do not guarantee every current command propagates
-every underlying error.
+## Exceptions to check
 
-## Current exceptions
+- `edit` does not propagate the editor child's status.
+- Machine `search` can return normally with no output for an invalid pattern;
+  a missing query can show human help.
+- A missing import source exits with status `2`.
+- A missing or unsupported tmux executable can print a diagnostic and return
+  status `0` before argument parsing.
+- `freeze` can catch a missing-session error, print it and return normally.
 
-`edit` ignores the editor child's status. Machine `search` can return normally
-with no output for an invalid regular expression, and with human help for a
-missing query. Both import children exit 2 when their source argument is
-missing. See their command pages before treating status alone as proof of
-success.
+Read both the command's output and [reference page](../../cli/) before using
+its status as the only success check.
 
-The root entry point checks for a supported tmux executable before parsing
-arguments, including help. Missing or unsupported tmux can print a diagnostic
-and exit with status 0. `tmuxp freeze` also catches a missing-session error, prints
-it, and returns normally. These are current implementation quirks.
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- /port -->
 
-## Proposed native behavior
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Check the process status before treating a result as complete. A failed load
+can report retained effects; a later failure does not undo an earlier input.
 
-Parse errors return 2 before backend work. Input validation or execution
-failures return 1. A partial operation includes completed work and the failed
-stage in its result and returns 1; it must not claim rollback unless rollback
-occurred. An interruption returns 130 after owned streams and handles are
-cleaned up, without killing unrelated tmux sessions.
+| Exit status | Meaning |
+| --- | --- |
+| `0` | Command completed; an explicitly declined prompt can also finish without changes |
+| `1` | Workspace validation or operation failure |
+| `2` | Invalid arguments or execution context |
+| `130` | Interrupted operation |
 
-Machine errors on stderr are compact JSON objects, one per line. Parse or
-validation failures before work leave stdout empty. Human errors stay readable
-text. Stable error codes complement readable messages; native exception objects
-and stack traces are not the public JSON schema.
-<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Child commands such as `edit` can propagate another nonzero child status.
+<!-- port:dotnet -->
+Status `70` reports an internal error.
+<!-- /port -->
+<!-- port:cxx -->
+Termination by SIGTERM can return `143`.
+<!-- /port -->
 
-## Machine error codes
+## Machine errors
 
-In `--json` and `--ndjson` mode an error record on stderr is
-`{"schema_version": 1, "code": ..., "message": ...}`, and every entry of a load
-summary's `errors` array carries the same `code`. The seven native ports report
-the same code for the same condition:
+With `--json` or `--ndjson`, diagnostics identify a `code` and readable
+`message`. Use the code for program decisions and keep the message for users.
 
-| Condition | Code |
+| Code | Condition |
 | --- | --- |
-| Workspace file or name not found | `workspace_not_found` |
-| Malformed document, wrong type, or invalid value | `invalid_workspace` |
-| An unknown or unsupported key refused | `unsupported_key` |
-| tmux missing, or its server unreachable | `tmux_unavailable` |
-| A tmux command failed while building | `tmux_failed` |
-| `before_script` exited nonzero, or could not start | `script_failed` |
-| A target session does not exist | `session_not_found` |
-| A destination exists without `--force` | `destination_exists` |
-| A confirmation is needed but impossible | `confirmation_required` |
-| Interrupted by a signal | `interrupted` |
-| Arguments or mode misused | `usage`, with status 2 |
+| `workspace_not_found` | Requested workspace was not found |
+| `invalid_workspace` | Document shape or value is invalid |
+| `unsupported_key` | An execution field is unsupported |
+| `session_not_found` | The selected session does not exist |
+| `session_mismatch` | Existing session does not match the requested document |
+| `tmux_unavailable` | tmux cannot be found or used |
+| `tmux_failed` | A tmux operation failed |
+| `script_failed` | A bootstrap process failed |
+| `destination_exists` | A file would be replaced without authorization |
+| `usage` | Arguments or execution context are invalid |
+| `interrupted` | A signal stopped the operation |
 
-Other conditions keep port-specific codes, in lower snake_case. Match on the
-code, not the message.
-<!-- /port -->
-
-See [output](../output/), [automation](../../guides/automation/), and
-[troubleshooting](../../guides/troubleshooting/).
+Additional codes describe implementation failures such as a closed output
+stream, unavailable runtime or log-file failure. Keep unknown codes visible
+instead of assuming they mean success. See [troubleshooting](../../guides/troubleshooting/)
+for collecting a useful report.
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/_workspace-shared/workspace/reference/output.md b/site/src/content/_workspace-shared/workspace/reference/output.md
index 37ab3a68..63e389da 100644
--- a/site/src/content/_workspace-shared/workspace/reference/output.md
+++ b/site/src/content/_workspace-shared/workspace/reference/output.md
@@ -1,296 +1,118 @@
 ---
-description: Python output and the native CLI stream and color contract.
+description: Read JSON results, NDJSON events and diagnostics from the workspace command.
 product: workspace
 sidebar:
   group: Reference
-  label: JSON, NDJSON, and semantic color
+  label: Output formats
   order: 29
 tableOfContents: true
-title: JSON, NDJSON, and semantic color
+title: Output formats
 ---
 
-<!-- port:py -->This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->**tmuxp compatibility reference.** Examples using `tmuxp` run the Python reference. [Local CLI status](../compatibility/) describes this port's implemented coverage.
-<!-- /port -->
-**Native CLI development contract.** The local `workspace-cli` worktrees provide JSON and NDJSON output. The schema below is the shared target; implemented command coverage remains port-specific. Python tmuxp provides JSON and NDJSON on `ls` and `search`, and JSON on `debug-info`.
+<!-- port:py -->
+Choose the output supported by each tmuxp command:
 
-## Format selection
+| Command | Machine output |
+| --- | --- |
+| `ls` | `--json` returns an object containing `workspaces`; `--ndjson` returns records |
+| `search` | `--json` and `--ndjson`; read the command's empty-result caveats |
+| `debug-info` | `--json` |
+| `freeze`, `convert`, imports | YAML or JSON workspace document output, separate from a result protocol |
 
-The shared contract accepts `--json` and `--ndjson` before or after every leaf command.
-NDJSON wins when both are present. A saved workspace's encoding is separate:
-`freeze -f yaml` describes the file, while `--json` describes the CLI result
-stream. Machine output has no ANSI styling, prompts, spinner frames, or raw
-child output.
-<!-- port:go,dotnet,cxx,swift -->
-<!-- /port --><!-- port:go -->## Native Go logging
-<!-- /port --><!-- port:dotnet -->The native .NET CLI disables machine styling and progress, but .NET Console
-initialization can still emit keypad controls when stdout is a terminal. Use
-redirected stdout for machine consumption. Console writes do not provide a
-hard cancellation deadline.
-<!-- /port --><!-- port:cxx -->## Native C++ load output
-<!-- /port --><!-- port:swift -->## Native Swift child output
-<!-- /port --><!-- port:go,dotnet,cxx,swift -->
-<!-- /port --><!-- port:go -->The native Go CLI uses `--log-level` to filter optional diagnostics and
-structured `--log-file` output on Unix. Levels are `debug`, `info`, `warning`,
-`error` and `critical`; the default is `warning`. Mandatory command errors,
-results and NDJSON operation events remain visible at every level.
-<!-- /port --><!-- port:dotnet -->For native .NET commands, `--log-level debug|info|warning|error|critical`
-filters optional warnings and file records; the default is `warning`. It does
-not suppress command errors or JSON/NDJSON result events.
-<!-- /port --><!-- port:cxx -->Human load publishes its summary and flushes stdout and stderr before terminal
-attachment or client switching. A handoff failure preserves loaded changes.
-If final publication fails, a writable diagnostic stream reports the completed
-summary under `retained_state`; human stderr labels the same observed state.
-A previous nonzero load status survives a later output failure.
-<!-- /port --><!-- port:swift -->The native Swift command streams `before_script` and captured `shell -c`
-output while the child runs. Human bootstrap output keeps its original stdout
-or stderr destination. Human shell output also preserves line breaks and tabs,
-escaping other terminal controls.
-<!-- /port --><!-- port:go,dotnet,cxx,swift -->
-<!-- /port --><!-- port:go -->`--log-file` appends UTF-8 JSON lines to a regular file. The CLI checks the
-destination before starting Python or tmux. A new file requests owner-only
-read/write permissions, subject to the process umask; existing content and
-permissions are preserved. A final-path symlink, FIFO, device or directory is
-rejected. Log files are unsupported on non-Unix platforms.
-<!-- /port --><!-- port:dotnet -->On Linux x64, native `load --log-file PATH` appends UTF-8 JSON lines without
-terminal colors. Select `info` for lifecycle records or `debug` to include
-script output. Relative paths use the invocation directory. New files allow
-only owner read/write; existing content and permissions are preserved.
-Directories, pipes, devices and symbolic links are rejected before tmux or
-Python runs. Other platforms reject `--log-file`.
-<!-- /port --><!-- port:cxx -->Closed event output while building retains completed inputs and borrowed-session
-effects in the failure summary. A known script failure keeps its status and
-captured output when its completion event cannot be delivered. Scripts can make
-additional changes outside the builder's retained-window records. NDJSON can
-emit its terminal result only while its output stream remains writable. See
-[loading and attachment](../../cli/load/#native-c-loading) for terminal and
-client requirements.
-<!-- /port --><!-- port:swift -->In JSON and NDJSON modes, child chunks are warning records on **stderr** with
-codes `bootstrap_stdout`, `bootstrap_stderr`, `shell_stdout` or `shell_stderr`.
-`--log-level error` and `critical` hide those warnings. Load events and results
-stay on stdout; the final shell result retains complete captured stdout/stderr
-and the child exit status even when warnings are hidden.
-<!-- /port --><!-- port:go,dotnet,cxx,swift -->
-<!-- /port --><!-- port:go -->The log includes lifecycle records at `info` and script stream text at `debug`.
-Lifecycle summaries omit script bodies. If writing or closing the log fails,
-logging stops and the CLI attempts at most one optional warning after work and
-terminal cleanup. The primary result, child exit status or cancellation status
-is preserved even if that warning cannot be written. This does not impose a
-filesystem write deadline or resolve every command-output failure path.
-<!-- /port --><!-- port:cxx -->## Native C++ logging
-<!-- /port --><!-- port:swift -->Each child stream is limited to one MiB. UTF-8 characters split across reads
-are retained until complete; invalid bytes use replacement characters. Output
-follows sink backpressure without replaying previous chunks. Overflow, failed
-writes and cancellation terminate the captured process group; a closed reader
-is detected on the next pending write.
-<!-- /port --><!-- port:go,cxx,swift -->
-<!-- /port --><!-- port:go -->## Native Go load failures
-<!-- /port --><!-- port:cxx -->`load --log-file PATH` appends one JSON diagnostic record per line. The global
-`--log-level` defaults to `warning`; `info` includes lifecycle events and `debug`
-adds script-output chunks. Other records omit structured script captures.
-Required errors and primary JSON/NDJSON results remain visible at every level.
-<!-- /port --><!-- port:go,cxx -->
-<!-- /port --><!-- port:go -->After processing an input, native load retains its observed summary for failure
-reporting. If final output fails or publication is interrupted, a writable
-machine diagnostic stream includes that summary under `result`. Human stderr
-lists observed session IDs and stages. These records describe the loading
-outcome; they do not recheck whether each session is still alive.
+```console
+$ tmuxp ls --json
+```
 
-A successfully built workspace can have `result.status: "ok"` when publication
-is interrupted and the command returns 130. A failed before script still removes
-its newly created session when the script-completion event cannot be written.
-Borrowed sessions survive; an output failure after a successful script also
-retains its session. Other effects before an input returns from building need
-separate coverage.
-<!-- /port --><!-- port:dotnet -->Failure to open the log prevents execution. A later write or close failure
-disables logging and reports at most one secondary warning; the workspace
-result, original error or cancellation is preserved. Python delegation leaves
-the file under native ownership, but still delegates the whole load and lacks
-native per-input accounting.
-<!-- /port --><!-- port:cxx -->The destination must be a regular file. New files receive owner-only
-permissions; existing contents and permissions are preserved. Invalid paths,
-symlinks and non-regular destinations fail before backend mutation. A later
-write failure disables the file and reports one optional warning after primary
-output checks. It preserves child status, cleanup and terminal handoff, but can
-leave an incomplete final log record.
-<!-- /port --><!-- port:swift -->On cancellation, load attempts one terminal failure result and fatal diagnostic
-with bounded writes. Writable stdout receives the terminal result; blocked or
-closed output cannot guarantee delivery. A diagnostic interrupted on blocked
-stderr may end mid-record. SIGINT and SIGTERM return status 130, and append
-failures preserve the borrowed session.
-<!-- /port -->
-## Machine output
+Do not assume every command accepts a global JSON mode. Read the
+[command reference](../../cli/) for flags, prompts and destinations, and
+[exit codes](../exit-codes/) before interpreting an empty stream as success.
 
-The document-to-stdout behaviors below are new machine-mode extensions. In the
-pinned reference, freeze always saves a file and quiet only suppresses status
-text. Separate the workspace file's encoding from the CLI stream's encoding.
-`freeze -f json` selects the document format. `--json` selects structured CLI
-output. Never append a status line to raw YAML or JSON document output.
+`--color auto|always|never`, `NO_COLOR` and `FORCE_COLOR` control human styling.
+Use explicit output formats when a script reads the result.
 
-| Command | JSON stdout | NDJSON stdout |
-| --- | --- | --- |
-| `ls` | Object containing `workspaces` and `global_workspace_dirs`, retaining tmuxp's existing record fields. Empty discovery yields the same object with an empty array. | One workspace record per line, matching tmuxp. Empty discovery emits zero records. Directory diagnostics stay on stderr. |
-| `search` | Array of result records with `"name"`, `"path"`, `"session_name"`, `"source"`, `matched_fields`, `"matches"`. Empty results yield `[]`. | One result record per line. Empty results emit zero records. |
-| `debug-info` | One diagnostics object. Retain home masking for named path fields, define redaction for raw tmux values, and add port/runtime details under named fields. | One compact diagnostics object plus newline. |
-| `tmuxp load` | Versioned operation summary: command, status, results, errors and completed/failed stages. | Ordered operation events followed by exactly one terminal result. |
-| `tmuxp freeze` | The workspace document as a JSON object when writing stdout; if saving to a file, a versioned save result containing destination, format and recoverability warnings. | One versioned capture/save result per line, with a `"workspace"` object when returning the document. |
-| `convert` and importer leaves | The converted document as JSON when writing stdout; a versioned save result when an explicit destination is supplied. | One versioned conversion/save result with a nested document when returning it. |
-| `edit` | One versioned result after the editor exits, including selected file and child status. | One terminal edit result; interactive editor display uses the terminal rather than machine stdout. |
-<!-- port:py,ts,rs,go,java,dotnet,cxx -->| `"shell"` | For `-c`, one result containing captured Python stdout/stderr and child status. Interactive REPL requires a separate terminal; otherwise reject before execution. | For `-c`, stream captured Python output events and one terminal result. Interactive behavior has the same terminal requirement. |
-<!-- /port --><!-- port:swift -->| `"shell"` | For `-c`, one result containing captured Python stdout/stderr and child status. Native Swift machine calls require `-c`. | Native Swift writes one terminal result to stdout; live child warnings use stderr as described above. |
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
 <!-- /port -->
-Keep the established read-command JSON shapes rather than forcing a new
-universal envelope around existing pipelines. New operation envelopes use
-integer `schema_version: 1`. Search's empty array is a deliberate correction to
-tmuxp 1.74.0's empty byte stream. No-pattern machine search must return usage
-status 2, empty stdout and a structured stderr diagnostic. Explicit `--help`
-remains a documented human-help request. Invalid patterns must return usage
-status 2 and a diagnostic; tmuxp's current JSON search can silently return no
-output for an invalid regex.
-
-A new load summary has `schema_version`, `"command"`, `"status"` (`ok`, `partial` or
-`"error"`), `results` and `errors`. Each result identifies its workspace input and
-created/reused session; IDs are strings because tmux uses prefixes such as `$`,
-`@` and `%`. Errors include a stable `code`, a readable `message`, the input
-index and any completed/failed stage. Do not serialize native exception objects,
-language-specific field capitalization or unserializable handles.
-
-<!-- port:ts,rs,go,java,dotnet,cxx,swift -->Every result names `input`, `input_index`, `session_id`, `session_name` and
-`reused`; ports add their own fields around those. An input that failed keeps
-its result record beside its `errors` entry, so a reader can tell which input
-failed and what became of its session. `status` is `ok` when every input
-completed, `partial` when some input completed or a failed one left effects
-behind, such as a borrowed or appended session, and `error` when nothing
-completed and nothing was retained.
-
-<!-- /port --><!-- port:ts -->TypeScript Python-extension loads report `effects_scope: "observed"` and
-`effects_unknown: true`, with `observed_windows` and `observed_panes` listing
-newly observed IDs. These lists may include concurrent changes and do not prove
-ownership. The CLI does not roll back extension effects; a failed or interrupted
-extension can leave a partial result. A daemon change is reported without
-comparing IDs across its lifetimes. Captured `script_output` retains up to
-64 KiB of source bytes per stream and reports truncation; NDJSON forwards
-escaped `script-output` records as output arrives.
-
-<!-- /port -->NDJSON operation events have `schema_version`, `"command"`, `event`, a
-monotonically increasing `"sequence"`, and event-specific data. The initial
-vocabulary is `started`, `workspace-started`, `session-created`,
-`window-created`, `pane-created`, `script-output`, `warning`,
-`workspace-completed`, `"failed"`, `"completed"`. Emit `"completed"` or `"failed"` once
-per invocation. Include operation/input identifiers where several files are
-<!-- port:py -->involved. Flush records as events arrive; buffering the whole run and splitting
-a JSON array into lines is not streaming.
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->involved. `workspace-started` names the `input` and `input_index` it belongs to,
-and `session-created` follows it directly, before any `window-created`, so a
-reader knows the session a window belongs to as soon as the windows arrive.
-Flush records as events arrive; buffering the whole run and splitting a JSON
-array into lines is not streaming.
-<!-- /port -->
-Drain child stdout and stderr concurrently to avoid pipe deadlocks. In machine
-mode, script text belongs inside escaped JSON strings; it must never be written
-directly to stdout. Apply backpressure, cap retained output and expose
-truncation explicitly. Line breaks, tabs, ANSI bytes, Unicode and arbitrary
-workspace names must remain valid encoded data. Binary output needs an explicit
-byte encoding or a documented replacement policy.
-
-Machine stderr contains one compact diagnostic JSON object per line.
-Parse/validation failures before work leave stdout empty and return 2 or 1
-respectively. A partial load emits a partial/failure result describing completed
-work and returns 1; do not claim rollback unless it occurred. Human-mode
-diagnostics remain readable text. Interruptions should stop scheduling new work,
-drain or close owned streams, release owned process handles, and return 130
-without killing unrelated tmux sessions.
-
-<!-- port:rs -->## Native Rust load reporting
-
-If publishing a load result fails, the local Rust CLI reports completed inputs
-and observed tmux effects on stderr. Machine diagnostics include this summary
-in `retained_state`; human diagnostics print it after the error. The CLI does
-not roll back loaded sessions or append changes when result output fails.
-
-A nonzero `before_script` exit status already collected by the CLI survives a
-later result publication failure. This guarantee does not cover Ctrl-C or
-failures before the child runner returns its captured output and status.
 
-## Native Rust logging
+<!-- port:ts,rs,go,java,dotnet,cxx,swift -->
+Every command accepts `--json` and `--ndjson`. JSON writes one document to
+stdout. NDJSON writes one JSON record per line and takes precedence if both
+flags are present. Machine output contains no terminal styling.
 
-The local `tmux-workspace load --log-file PATH` appends JSON records to a
-regular file. New files have owner-only permissions; existing contents and
-permissions are preserved. Invalid destinations, including symlinks, are
-rejected before tmux or Python runs.
+## Choose a stream
 
-The default `--log-level` is `warning`. `info` includes load events; `debug`
-also records child output, capped at 1 MiB of decoded UTF-8 per stream per
-child with truncation marked. Lifecycle records omit captured streams,
-including nested result captures; diagnostic messages are preserved.
+```console
+$ tmux-workspace ls --json
+```
 
-A later file-write failure disables logging. Its optional warning follows the
-command result or error; levels above `warning` suppress it. Log filtering
-does not suppress command errors or change their exit statuses.
-<!-- /port --><!-- port:dotnet -->If publishing a native .NET load's final JSON/NDJSON result fails or is
-interrupted, the stderr diagnostic includes completed workspace effects.
-Those completed changes remain in tmux; an output failure does not imply
-rollback.
-<!-- /port --><!-- port:rs,dotnet -->
-<!-- /port -->## Prompts and file writes
+The shape depends on the operation: listing and search describe workspace
+records; conversion and import can return the translated document; loading
+describes completed work and failures. Saving a document returns information
+about that save. The file's YAML/JSON encoding is controlled separately by
+`--workspace-format`.
 
-Machine mode resolves choices from arguments and never treats missing input as
-yes. Detached loading avoids mixing terminal attachment with JSON. Interactive
-editor and REPL display require a separate controlling terminal; otherwise the
-command rejects the request before execution.
+Use [automation](../../guides/automation/) for a detached load and streamed
+progress. Read stdout as results and stderr as diagnostics. Check the exit
+status even when stdout contains valid data.
 
-<!-- port:py -->The proposal adds explicit save, format, and overwrite controls to
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->The native contract defines explicit save, format, and overwrite controls for
-<!-- /port -->conversion/import automation. With no destination, machine conversion returns
-the document and writes no guessed file. Existing files require explicit
-<!-- port:py -->overwrite authorization, including explicit freeze destinations. These are
-proposed improvements over the Python overwrite behavior documented by
-<!-- /port --><!-- port:ts,rs,go,java,dotnet,cxx,swift -->overwrite authorization, including explicit freeze destinations. These rules
-differ from the Python overwrite behavior documented by
-<!-- /port -->[freeze](../../cli/freeze/) and [convert](../../cli/convert/).
+## Partial work and interrupted streams
 
-## Semantic color
+Load results can contain completed inputs, created IDs and retained effects.
+Treat a failed operation as partial until its result tells you what remains.
+A creation event alone does not establish that the workspace finished.
 
-Use roles at the point that a domain value is rendered. Formatting an entire
-line with one success color loses the structure the requested style should
-communicate. Compose a status, subject, identifiers, paths, counts and hints
-separately, and reset styling after every token.
+An output failure or interruption can leave a final record unwritten or
+incomplete. A consumer must handle EOF and parse errors. Preserve the exit
+status and inspect the private server before retrying mutations.
 
-| Role | Default tmuxp-aligned style | Typical values |
-| --- | --- | --- |
-| Heading | Bold bright cyan | Command and section headings |
-| Primary subject | Bold magenta | Workspace/session name, selected window |
-| Information | Cyan | Paths, targets, useful values |
-| Success | Green | Created, loaded, saved |
-| Warning | Yellow | Partial support, lossy capture, retained objects |
-| Error | Red | Failed operation, invalid field |
-| Secondary text | Blue or dim text, verified against terminal contrast | Sizes, timestamps, source labels, hints |
-| Command syntax | Distinct option/argument roles from the same theme | Flags, metavariables, examples |
+## Child output and logging
 
-Copy tmuxp's policy explicitly: nonempty `NO_COLOR` disables; explicit never
-disables; explicit always enables; nonempty `FORCE_COLOR` enables auto;
-otherwise use the destination stream's terminal capability. To support the
-supplied reports' extra variables, add `CLICOLOR_FORCE` and `CLICOLOR` below
-those explicit/reference choices. `CLICOLOR_FORCE=0` does not force. Machine
-mode takes precedence over all color choices, including forced color.
+Machine calls encode captured child text so it cannot be confused with result
+records. The optional [inspection shell](../../cli/shell/) reports its child
+status along with captured output. A nonzero editor status is propagated.
 
-Measure layout using visible terminal width, not byte length or ANSI-bearing
-string length. Exercise narrow terminals, wrapped paths, Unicode and redirected
-output. Keep status words and labels even when color is enabled, so meaning
-survives monochrome output. Progress updates belong on stderr, animate only on a
-terminal, and become discrete records in NDJSON mode. Honor the reference
-progress presets, custom tokens and panel-line rules.
+<!-- port:swift -->
+Bootstrap and inspection output streams as warning records on stderr, with up
+to one MiB per stream. The final result carries captured text. `--log-level`
+can filter advisory records; fatal errors and results remain visible.
+<!-- /port -->
+<!-- port:ts -->
+Captured child results retain up to 64 KiB of source bytes per stream and mark
+truncation. NDJSON forwards child output as it arrives.
+<!-- /port -->
+<!-- port:rs,go,java,dotnet,cxx -->
+NDJSON can carry child-output records while a command is running. Read the
+terminal result and child status after those records.
+<!-- /port -->
 
-<!-- port:dotnet -->Native .NET human load draws progress on stderr on Linux x64. With the panel
-disabled, decoded script stdout and stderr retain their original destinations.
-Resizing stops drawing and leaves the old frame in place. See
-[load](../../cli/load/#progress-and-script-output) for native counters and
-progress settings.
+`load --log-file PATH` appends diagnostics to a separate file. `--log-level`
+selects advisory detail. A later log-file failure reports a diagnostic and
+preserves the operation's result; the log can end with an incomplete record.
 
-<!-- /port -->## Related reference
+## Human output
 
-See [exit codes](../exit-codes/), [command flags](../../cli/), and
-[environment](../../configuration/environment/).
+`--color auto|always|never` selects styling; nonempty `NO_COLOR` disables color.
+Human progress uses the terminal. `--no-progress` disables drawing without
+hiding errors. Redirected or machine output avoids the progress display.
 
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+<!-- port:ts -->
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
+<!-- /port -->
+<!-- port:rs -->
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
+<!-- /port -->
+<!-- port:go -->
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
+<!-- /port -->
+<!-- port:java -->
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
+<!-- /port -->
+<!-- port:dotnet -->
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
+<!-- /port -->
+<!-- port:cxx -->
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
+<!-- /port -->
+<!-- port:swift -->
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
+<!-- /port -->
+<!-- /port -->
diff --git a/site/src/content/docs/concepts/index.md b/site/src/content/docs/concepts/index.md
index 32123a91..7d8ff0fc 100644
--- a/site/src/content/docs/concepts/index.md
+++ b/site/src/content/docs/concepts/index.md
@@ -1,6 +1,6 @@
 ---
 title: Concepts
-description: tmux objects, command transports, queries, and workspaces across the libtmux language ports.
+description: tmux objects, command transports, queries, and workspaces.
 sidebar:
   label: Overview
   group: Concepts
@@ -11,7 +11,8 @@ libtmux lets you create sessions, arrange windows and panes, send commands, and
 read output from tmux. Start with the object hierarchy, then read about the
 transport, query, or workspace behavior your program needs.
 
-These pages explain shared concepts and differences between language ports:
+<!-- port:root,py,ts,rs,go,java,dotnet,cxx,swift -->
+Choose the concept behind your task:
 
 - **[Server, session, window, pane](server-session-window-pane/)**: tmux's
   object hierarchy and attached clients.
@@ -22,5 +23,11 @@ These pages explain shared concepts and differences between language ports:
 - **[Workspaces](workspaces/)**: build pane layouts from code or configuration
   files.
 
-Use the header's port links to open documentation for your language, including
-its API reference.
+<!-- /port -->
+
+<!-- port:ruby,lua,kotlin,scala,fsharp -->
+Start with [the object hierarchy](server-session-window-pane/), then use
+[the native guides](../guides/) for queries, execution, and resource ownership.
+<!-- /port -->
+
+Use the API reference for signatures, defaults, and failure conditions.
diff --git a/site/src/content/docs/concepts/queries.md b/site/src/content/docs/concepts/queries.md
index 00d4bc51..01b33818 100644
--- a/site/src/content/docs/concepts/queries.md
+++ b/site/src/content/docs/concepts/queries.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Filtering and queries
 description: How you get from every session on the server to the one pane you mean, and what happens when zero or several match.
 sidebar:
@@ -12,15 +13,17 @@ Use a collection filter to find matching sessions, windows, or panes. Use an
 exactly-one lookup when your next operation requires a single target.
 
 - **Filtering returns a collection; exactly-one lookup checks the result
-  count.** A `.filter()` or `.where()` call returns zero or more matches. Methods
-  such as `.get()`, `.one()`, and `Selections.exactlyOne()` return one object or
-  report a missing or ambiguous match.
+  count.** A filter returns zero or more matches. An exactly-one operation
+  returns one object or reports a missing or ambiguous match.
 
 - **Choose where to filter.** Filter a snapshot in your program when you need
   several queries over the same data. A tmux format filter can reduce the rows
   returned by a live read. The cost depends on the data and queries you need.
 
-## Python: `.filter()` and `.get()`, Django-style
+<!-- port:py -->
+<a id="python-filter-and-get-django-style"></a>
+
+## Filter collections and select one object
 
 `server.sessions`, `session.windows`, and `window.panes` are `QueryList`
 collections. Call `.filter()` with field names and optional lookup suffixes:
@@ -58,8 +61,12 @@ filter grammar requires tmux 3.2 or newer. An unknown format token expands to an
 empty value, so a malformed filter can look like a valid filter with no matches.
 If `search_*()` unexpectedly returns no results, try `#{m:*,#{session_name}}` to
 check that the session data is available.
+<!-- /port -->
+
+<!-- port:ts -->
+<a id="typescript-criteria-as-data"></a>
 
-## TypeScript: criteria as data
+## Criteria as data
 
 TypeScript's `Selection.where()` accepts structured, serializable criteria that
 can be stored in a configuration file or sent through MCP:
@@ -78,27 +85,36 @@ enables case-insensitive comparison. Use `.where()` for criteria that can be
 encoded with `encodeWhereDocument` and decoded with `decodeWhereDocument`; use
 `.filter()` for a predicate function. `.one()` throws `NoMatchError` or
 `MultipleMatchesError`. `.oneOrUndefined()` permits an absent result.
-
-## Go, Rust, Java, C++: typed fields that fail queries at compile time
-
-These ports use typed fields to reject invalid comparisons at compile time:
-
-- **Go** offers both `tmux.PaneFilter{Active: tmux.Ptr(true), ...}` structs
-  that push down into `SearchPanes` (one tmux command, only matches
-  returned), and a `snapshot()` read followed by `tmuxq.Where(panes,
-  predicate)` when you want several answers from one read.
-- **Rust** uses typed fields: `fields.pane_active.eq(true)` is valid, but
-  `.gt(...)` on that boolean field is not. Expressions compose with `.and()`.
-  With the `serde` feature, a query can be encoded as a versioned JSON document
-  for configuration or MCP.
-- **Java** exposes each field as a typed accessor (`Pane_.index()`,
-  `Session_.name()`) that plugs straight into an ordinary `Stream.filter()`;
-  `Pane_.index().startsWith("2")` doesn't compile because the index is a
-  number, not a string. `Selections.exactlyOne(...)` is the `.get()`-shaped
-  call, throwing `NoMatchException` or `MultipleMatchesException`.
-- **C++** composes `FilterExpr` values with `&&`, `||`, and `!`, as in
-  `pane::command.starts_with("nv") && pane::active`. Invalid field operations
-  such as `pane::active.starts_with("x")` fail to compile.
+<!-- /port -->
+
+<!-- port:go,rs,java,cxx,dotnet,swift -->
+<a id="go-rust-java-c-typed-fields-that-fail-queries-at-compile-time"></a>
+
+## Typed and local filters
+
+Typed field operations let the compiler reject incompatible comparisons:
+
+<!-- port:go -->
+`tmux.PaneFilter` describes a typed predicate over captured values. Use
+`tmuxq.Matching` or compile its `PaneFilter.Predicate()` for local queries. To filter a
+live tmux listing, pass a `TmuxFilter` expression to `Server.SearchPanes`.
+<!-- /port -->
+<!-- port:rs -->
+Typed fields reject invalid comparisons: `fields.pane_active.eq(true)` is
+valid, while `.gt(...)` on a boolean field fails to compile. Compose
+expressions with `.and()`. The `serde` feature supports versioned query
+JSON for configuration or MCP.
+<!-- /port -->
+<!-- port:java -->
+`Pane_`, `Window_`, and `Session_` expose typed field accessors for stream
+predicates. A numeric field has no `startsWith` operation. Use
+`Selections.exactlyOne` to reject absent or ambiguous matches.
+<!-- /port -->
+<!-- port:cxx -->
+Compose `FilterExpr` values with `&&`, `||`, and `!`. For example,
+`pane::command.starts_with("nv") && pane::active` is valid, while
+`pane::active.starts_with("x")` fails to compile.
+<!-- /port -->
 
 Examples of typed and local filters:
 
@@ -131,7 +147,7 @@ active := tmuxq.Where(snapshot.Panes(), predicate)
 fmt.Println("active panes:", len(active))
 
 // Or push the filter down: tmux returns only the matches.
-filter := tmux.PaneFilter{Active: tmux.Ptr(true)}
+filter := tmux.TmuxFilter("#{==:#{pane_active},1}")
 panes, err := server.SearchPanes(ctx, &filter)
 if err != nil {
 	return err
@@ -183,14 +199,21 @@ let editors = try await server.panes().filter { $0.currentCommand == "nvim" }
 let expression = try FilterExpr<Pane>.where(\.currentCommand, .isIn(["nvim", "vim"]))
 let matching = try await server.panes().filter(expression)
 ```
+<!-- /port -->
 
-## The cardinality contract, side by side
+<a id="the-cardinality-contract-side-by-side"></a>
 
+## Result counts
+
+<!-- port:py,ts,java -->
 | Port | Collection filter | Exactly-one | Empty | Several |
 |------|--------------------|--------------|-------|---------|
-| Python | `.filter()` | `.get()` | `ObjectDoesNotExist` (or `default=`) | `MultipleObjectsReturned` |
-| TypeScript | `.where()` / `.filter()` | `.one()` | `NoMatchError` (or `.oneOrUndefined()`) | `MultipleMatchesError` |
-| Java | `Stream.filter()` | `Selections.exactlyOne()` | `NoMatchException` | `MultipleMatchesException` |
-
-See the Go, Rust, C++, .NET, and Swift references for their exactly-one result
-types and failure handling.
+<!-- port:py -->| Python | `.filter()` | `.get()` | `ObjectDoesNotExist` (or `default=`) | `MultipleObjectsReturned` |
+<!-- /port --><!-- port:ts -->| TypeScript | `.where()` / `.filter()` | `.one()` | `NoMatchError` (or `.oneOrUndefined()`) | `MultipleMatchesError` |
+<!-- /port --><!-- port:java -->| Java | `Stream.filter()` | `Selections.exactlyOne()` | `NoMatchException` | `MultipleMatchesException` |
+<!-- /port -->
+<!-- /port -->
+
+[Filtering and querying](/guides/querying-and-filtering/) shows exactly-one
+lookups and their error handling. Do not index the first result until the
+operation has established that a match exists.
diff --git a/site/src/content/docs/concepts/server-session-window-pane.md b/site/src/content/docs/concepts/server-session-window-pane.md
index 09a9d69b..f3d912d0 100644
--- a/site/src/content/docs/concepts/server-session-window-pane.md
+++ b/site/src/content/docs/concepts/server-session-window-pane.md
@@ -34,11 +34,11 @@ remains stable for that object's lifetime even if its name or index changes:
 | Pane | `%` | `%5433` |
 | Server | - | identified by socket name or path instead |
 
-Python handles use the object ID to refresh their fields. Immutable snapshots,
-such as those in TypeScript, Swift, and Go, use IDs to identify the same tmux
-object across reads.
+Use stable IDs to identify the same tmux object across reads. Names and indexes
+can change while a program is running.
 
-Walking the whole tree, in each port:
+<!-- port:py,ts,rs,go,java,dotnet,cxx,swift -->
+Read the hierarchy:
 
 ```python
 for session in server.sessions:
@@ -84,6 +84,9 @@ for branch in server.hierarchy().await? {
 // A snapshot reads sessions, windows, and panes in one pass; relations
 // resolve against it without another tmux command.
 snapshot, err := server.Snapshot(ctx)
+if err != nil {
+    return err
+}
 for _, session := range snapshot.Sessions() {
 	name, _ := session.Name()
 	fmt.Printf("%s %q\n", session.ID(), name)
@@ -166,6 +169,8 @@ for session in snapshot.sessions {
 }
 ```
 
+<!-- /port -->
+
 ## Client: a view, not a child
 
 A `Client` represents a terminal attached to a session. Several clients can view
@@ -177,6 +182,7 @@ A [control-mode connection](../transports/) is also a client. It appears in
 attachment-dependent behavior such as `destroy-unattached`. Closing the last
 attached client can therefore destroy a session configured with that option.
 
+<!-- port:root -->
 ## What differs between ports
 
 Ports differ in how they read state and report failures:
@@ -194,3 +200,19 @@ Ports differ in how they read state and report failures:
 
 See [Control mode vs one-shot](../transports/) for command costs and connection
 behavior.
+<!-- /port -->
+
+
+<!-- port:go -->
+## Snapshots and live commands
+
+`Server.Snapshot(ctx)` reads the hierarchy. The resulting relationship methods
+read that captured data without another tmux command. A boolean return value
+reports whether a relationship was captured. Use `Session.SearchWindows` or
+`Server.SearchPanes` for current live state, and check the returned error.
+
+Calls that contact tmux accept a context for cancellation and deadlines.
+Cancelling a mutation does not prove that tmux never received it; check the
+resulting state before retrying. [Errors and exceptions](/topics/errors-and-exceptions/)
+covers failure handling.
+<!-- /port -->
diff --git a/site/src/content/docs/concepts/transports.md b/site/src/content/docs/concepts/transports.md
index c44f68d7..e8bb09bc 100644
--- a/site/src/content/docs/concepts/transports.md
+++ b/site/src/content/docs/concepts/transports.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Control mode vs one-shot
 description: How a call in your program actually reaches the tmux server, and why a port might give you a choice.
 sidebar:
@@ -9,13 +10,10 @@ tableOfContents: true
 ---
 
 libtmux sends commands to tmux through subprocesses or persistent control-mode
-connections. Some ports also batch commands into one invocation:
+connections. tmux also accepts several commands in one invocation:
 
 1. **One-shot subprocess.** Each command spawns a fresh `tmux` process,
-   which parses argv, executes the command, prints its output, and exits. This is
-   the default in every port, and the *only* lane in Python: every `.cmd()`
-   call underneath the object API is a `subprocess.Popen` around a `tmux`
-   invocation.
+   which sends the request to the server, prints the result, and exits.
 2. **A persistent control-mode client.** `tmux -C attach-session` starts one
    long-lived tmux process that stays attached and speaks a line-oriented
    protocol over its stdout: commands go in, replies and asynchronous
@@ -26,74 +24,94 @@ connections. Some ports also batch commands into one invocation:
    can fold several logical operations into a single process start without
    opening a control-mode connection at all.
 
-## Where each port draws the line
+<a id="where-each-port-draws-the-line"></a>
+
+## Available transports
 
 | Port | One-shot | Folded invocation | Persistent control client |
 |------|----------|--------------------|-----------------------------|
-| Python | every call | - | test-only (`ControlMode`, `libtmux._internal`) |
-| TypeScript | default | `pipeline()`, `batch()` | `connect()` / `watch()`: notifications only, commands stay per-process |
-| Go | `process` path | `Plan.Run` | `connection` (`Session.OpenControl`), `streaming` (`OpenNotifications`) |
-| Rust | `plan` feature, sequential | `plan`, folded | `control-mode` feature |
-| C# | "One-shot" mode | "Chained" mode (`server.Chain()`) | "Control" mode (`EnterControlModeAsync`) |
-| C++ | bounded subprocess (default) | `Chain` | `Server::control()` → `Connection` |
-| Java | every call | `Batch` | `ControlClient` (`attach`, `send`, `subscribeEvents`) |
-| Swift | default | - | `server.connect()` / `.watch()` (notifications; see below) |
-
+<!-- port:py -->| Python | every call | - | test-only (`ControlMode`, `libtmux._internal`) |
+<!-- /port --><!-- port:ts -->| TypeScript | default | `pipeline()`, `batch()` | `connect()` / `watch()`: notifications only, commands stay per-process |
+<!-- /port --><!-- port:go -->| Go | `process` path | `Plan.Run` | `connection` (`Session.OpenControl`), `streaming` (`Session.OpenNotifications`) |
+<!-- /port --><!-- port:rs -->| Rust | `plan` feature, sequential | `plan`, folded | `control-mode` feature |
+<!-- /port --><!-- port:dotnet -->| C# | "One-shot" mode | "Chained" mode (`server.Chain()`) | "Control" mode (`EnterControlModeAsync`) |
+<!-- /port --><!-- port:cxx -->| C++ | bounded subprocess (default) | `Chain` | `Server::control()` → `Connection` |
+<!-- /port --><!-- port:java -->| Java | every call | `Batch` | `ControlClient` (`attach`, `send`, `subscribeEvents`) |
+<!-- /port --><!-- port:swift -->| Swift | default | - | `Server.connected(attachingTo:_:)` / `ControlConnection.watch(_:)` |
+<!-- /port -->
 Choose based on whether you need command results, notifications, or a batch of
 changes.
 
+<!-- port:ts,go,dotnet,java,rs -->
 ## Notifications and commands are separable
 
+<!-- port:ts -->
 TypeScript's `connect()` adds an event observer while commands such as
 `session.newWindow(...)` and `pane.sendKeys(...)` continue to run as separate
 tmux processes. A dedicated process provides a completion boundary for output
 from alias-expanded or waiting commands.
+<!-- /port -->
+
+
+
+<!-- port:go -->
+`Session.OpenControl` opens a persistent command connection. `Session.OpenNotifications`
+opens a notification stream. Close each handle when finished. Starting an
+observer does not change the transport used by an existing server handle.
+<!-- /port -->
+<!-- port:dotnet -->
+Use `EnterControlModeAsync` for commands on a persistent connection.
+<!-- /port -->
+<!-- port:java -->
+`ControlClient.send` sends commands through the persistent connection.
+<!-- /port -->
+<!-- port:rs -->
+Enable the `control-mode` feature to send commands through a persistent
+connection.
+<!-- /port -->
 
-Go's `Session.OpenControl`, .NET's `EnterControlModeAsync`, Java's
-`ControlClient.send`, and Rust's `control-mode` feature can send commands
-through the persistent connection.
-Check your port's transport API before assuming that subscribing to events also
-changes how commands run.
+<!-- /port -->
 
 ## A control client is a real client
 
 A persistent control connection attaches a tmux client. It appears in
 `list-clients`, increments `session_attached`, and affects `destroy-unattached`,
 client hooks, and idle-client accounting. Each connection counts separately.
+<!-- port:py -->
 Python's internal `ControlMode` test helper uses this behavior for commands that
 require an attached client, such as `display-popup` and `detach-client`.
+<!-- /port -->
+
+
 
 ## Why fold several commands into one invocation
 
 Creating an object can require a second command to read its resulting state.
-Batching reduces those repeated reads and process starts. TypeScript's `batch()`
-resolves planned mutations from one final snapshot. Go's `Plan`, .NET's `Chain`,
-and C++'s `Chain` also group operations without attaching a control client.
+Batching can reduce repeated reads and process starts.
 
-## What this costs in practice
+<!-- port:ts -->
+`batch()` resolves planned mutations from one final snapshot.
+<!-- /port -->
+<!-- port:go -->
+A `Plan` groups operations without attaching a control client.
+<!-- /port -->
+<!-- port:dotnet,cxx -->
+A `Chain` groups operations without attaching a control client.
+<!-- /port -->
 
-The Rust `matrix` example and .NET README compare process counts and timings.
-Their results describe specific workloads and environments:
+<a id="choosing-a-lane"></a>
 
-- **Rust's** `matrix` example runs the same create-and-query workload five
-  ways. Blocking sequential and async sequential both cost 6 processes for 6
-  dispatches; folding the same 6 into async batches costs 3 processes;
-  routing them over a control-mode connection costs exactly 1.
-- **C#'s** README reports the *marginal* cost of one more command in each
-  mode, as medians against tmux 3.7b: roughly 2.3 ms for another one-shot
-  process, roughly 0.2 ms for another command over an already-open control
-  client, and roughly 0.02 ms for another command folded into one chained
-  invocation.
+## What this costs in practice
 
 A persistent connection avoids starting a client for each command. A chain
 groups a known sequence into one invocation. For occasional commands, use the
 default subprocess transport; measure your workload before changing transports
 for performance. Use a notification stream when your program needs tmux events.
 
-## Choosing a lane
+## Sending a command
 
-These examples use each port's subprocess API. See the port reference for
-batching and control-mode setup.
+The example uses the subprocess API. See the reference for batching and
+control-mode setup.
 
 ```python
 import libtmux
@@ -130,7 +148,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 ```
 
 ```go
-ctx := context.Background()
+ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+defer cancel()
 
 // One-shot: every call underneath this handle spawns a `tmux` process.
 server, err := tmux.NewServer(tmux.ServerOptions{})
@@ -145,7 +164,7 @@ window, err := session.ResolveActiveWindow(ctx)
 if err != nil {
 	return err
 }
-pane, _, err := window.ResolveActivePane(ctx)
+pane, err := window.ResolveActivePane(ctx)
 if err != nil {
 	return err
 }
diff --git a/site/src/content/docs/concepts/workspaces.md b/site/src/content/docs/concepts/workspaces.md
index d220d541..fa7d8bfd 100644
--- a/site/src/content/docs/concepts/workspaces.md
+++ b/site/src/content/docs/concepts/workspaces.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Workspaces
 description: Build pane layouts with the object API or a workspace configuration file.
 sidebar:
@@ -108,32 +109,38 @@ let logs = try await server.split(terminal, direction: .right)
 try await server.selectLayout(window, "main-vertical")
 ```
 
-`Window.split()` or `Pane.split()` adds a pane. Direction and size control its
-placement. `select_layout()` rearranges the panes while their processes continue
-running. tmux provides `even-horizontal`, `even-vertical`, `main-horizontal`,
+A split creates a pane; direction and size control its placement. Applying a
+layout rearranges existing panes while their processes continue running. tmux provides `even-horizontal`, `even-vertical`, `main-horizontal`,
 `main-vertical`, and `tiled` layouts.
 
-Python's `attach=False` and C++'s detached creation keep new windows in the
-background. Check the creation defaults for your port if focus matters. Splits
-and resizes require tmux commands; [Control mode vs one-shot](../transports/)
+Choose detached creation when the user's current window should retain focus.
+Splits and resizes issue tmux commands; [Control mode vs one-shot](../transports/)
 covers their transport costs and batching.
 
+<!-- port:py -->
+`attach=False` keeps a newly created window in the background.
+<!-- /port -->
+
 ## Building one declaratively
 
 These packages read or build workspace configurations based on tmuxp:
 
 | Port | Package | Shape |
 |------|---------|-------|
-| Python | tmuxp itself | the format this whole idea is named after |
-| TypeScript | `@libtmux/workspace` | `applyWorkspace(server, { session_name, windows: [...] })` |
-| Go | `workspace` | tmuxp-shaped, per the port's own module layout |
-| Rust | `tmux-workspace` | tmuxp-shaped |
-| Java | `libtmux-workspace` | "enough of tmuxp's format to describe a workspace" |
-| C# | `LibTmux.Workspace` | reads tmuxp YAML directly |
-| Swift | `TmuxWorkspace` | Swift, JSON, or YAML (YAML needs the `YAMLWorkspaces` trait) |
-
+<!-- port:py -->| Python | tmuxp itself | the format this whole idea is named after |
+<!-- /port --><!-- port:ts -->| TypeScript | `@libtmux/workspace` | `applyWorkspace(server, { session_name, windows: [...] })` |
+<!-- /port --><!-- port:go -->| Go | `workspace` | tmuxp-shaped, per the port's own module layout |
+<!-- /port --><!-- port:rs -->| Rust | `tmux-workspace` | tmuxp-shaped |
+<!-- /port --><!-- port:java -->| Java | `libtmux-workspace` | "enough of tmuxp's format to describe a workspace" |
+<!-- /port --><!-- port:dotnet -->| C# | `LibTmux.Workspace` | reads tmuxp YAML directly |
+<!-- /port --><!-- port:swift -->| Swift | `TmuxWorkspace` | Swift, JSON, or YAML (YAML needs the `YAMLWorkspaces` trait) |
+<!-- /port -->
+<!-- port:ts -->
 TypeScript's `applyWorkspace` applies a desired configuration. Applying the same
 configuration again reuses its existing objects:
+<!-- /port -->
+
+
 
 ```ts
 await applyWorkspace(server, {
@@ -158,6 +165,10 @@ if err != nil {
 	return err
 }
 session, err := workspace.Build(ctx, server, described)
+if err != nil {
+    return err
+}
+fmt.Println("workspace session:", session.ID())
 ```
 
 ```java
@@ -178,9 +189,13 @@ let workspace = Workspace(
 let session = try await WorkspaceBuilder.build(workspace, on: server)
 ```
 
+<!-- port:cxx -->
 C++ provides a consumer example in `examples/workspace/` that reads tmuxp
 configuration. The workspace builder is part of that example, rather than a
 library package:
+<!-- /port -->
+
+
 
 ```cpp
 // Not a package: this is the examples/workspace/ consumer, showing the
@@ -193,8 +208,17 @@ const auto built = workspace::build(server, description);
 
 ## Cleaning up
 
-For temporary workspaces, Python's `Window` and `Session` context managers kill
-their objects on block exit, including when the block raises:
+<!-- port:py -->
+`Window` and `Session` context managers kill their objects on block exit,
+including when the block raises:
+<!-- /port -->
+<!-- port:go -->
+Use a named error result in the enclosing function so deferred cleanup can
+return its own failure. Give cleanup a fresh, bounded context:
+<!-- /port -->
+<!-- port:dotnet -->
+An ownership scope kills its session when `await using` exits:
+<!-- /port -->
 
 ```python
 with session.new_window(window_name='temp-window') as temp_win:
@@ -218,8 +242,6 @@ defer func() {
 ```
 
 ```csharp
-// The closest match: an owning scope returned alongside the session,
-// disposed with `await using` the same way Python's `with` block is.
 await using OwnedSessionScope scope = await server.CreateOwnedSessionAsync(
     new NewSessionRequest(name: "temp-session"));
 Window window = (await scope.Value.GetWindowsAsync())[0];
diff --git a/site/src/content/docs/examples/attach-and-send-keys.md b/site/src/content/docs/examples/attach-and-send-keys.md
index 163f3a17..d16c9d2a 100644
--- a/site/src/content/docs/examples/attach-and-send-keys.md
+++ b/site/src/content/docs/examples/attach-and-send-keys.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Attach and send keys
 description: Get a session handle, send a command to a pane, and capture output.
 sidebar:
@@ -12,9 +13,8 @@ Get a session handle, send a command to a pane, and capture output. These
 examples use libtmux from your program; to attach your terminal interactively,
 see [Attaching to tmux](/guides/attaching-to-tmux/).
 
-Select your port below. The examples retain their source's setup, error
-handling, and cleanup, so the operations shown vary by port. [Where this comes
-from](#where-this-comes-from) identifies each source and its test coverage.
+The examples include setup, error handling, and cleanup. [Source and
+verification](#where-this-comes-from) identifies their files and checks.
 
 ```python
 >>> import libtmux
@@ -94,7 +94,10 @@ practice](/guides/querying-and-filtering/) covers absent and ambiguous matches.
 
 ## Where this comes from
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 **Source:** `src/libtmux/server.py`, `session.py`, `pane.py` docstrings
 
@@ -102,8 +105,12 @@ practice](/guides/querying-and-filtering/) covers absent and ambiguous matches.
 
 **Checked by:** `pytest` runs every `>>>` doctest (`testpaths` includes
 `src/libtmux`) against a real, isolated tmux session on every test run
+<!-- /port -->
 
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 **Source:** `examples/quickstart/quickstart.ts`
 
@@ -112,8 +119,12 @@ practice](/guides/querying-and-filtering/) covers absent and ambiguous matches.
 **Checked by:** run against real tmux by `bun test examples`; its first half is
 also mirrored into README.md under a `<!-- runs: ... -->` marker, checked
 line-for-line by `scripts/check-doc-runnable.ts`
+<!-- /port -->
 
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 **Source:** `crates/libtmux/examples/scratch.rs`
 
@@ -122,8 +133,12 @@ line-for-line by `scripts/check-doc-runnable.ts`
 **Checked by:** run to completion against a throwaway tmux by
 `scripts/run-examples.sh` (`just examples`), which CI runs and which also
 asserts the example leaves no session behind
+<!-- /port -->
 
+<!-- port:go -->
+<!-- port:root -->
 ### Go
+<!-- /port -->
 
 **Source:** `examples/quickstart/main.go`
 
@@ -132,8 +147,12 @@ asserts the example leaves no session behind
 **Checked by:** the whole file runs against a real tmux server as
 `TestQuickstart`; the `docs:quickstart` region inside it is additionally
 mirrored into README.md by `go generate ./tmux`, and CI fails if the two drift
+<!-- /port -->
 
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
 **Source:**
 `examples/src/main/java/io/github/libtmux/examples/BuildAWorkspace.java`
@@ -142,8 +161,12 @@ mirrored into README.md by `go generate ./tmux`, and CI fails if the two drift
 
 **Checked by:** run against real tmux by the `examples` module's own
 `ExamplesRunTest`
+<!-- /port -->
 
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 **Source:** `examples/LibTmux.Examples/Snippets/OneShot.cs`
 
@@ -152,8 +175,12 @@ mirrored into README.md by `go generate ./tmux`, and CI fails if the two drift
 **Checked by:** its `ConnectAndBuild` region is mirrored into README.md and
 checked by `sync_snippets.py --check`; the mirrored `csharp run` block is
 additionally compiled and run by `ReadmeExampleTests`
+<!-- /port -->
 
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
 **Source:** `examples/05-readme.cpp`, the `connect` and `build` regions
 
@@ -161,8 +188,12 @@ additionally compiled and run by `ReadmeExampleTests`
 
 **Checked by:** quoted verbatim into README.md, checked for drift by
 `tools/docs/check_readme.py`, and the whole file is built and run by CTest
+<!-- /port -->
 
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 **Source:** `Examples/Sources/ExampleCode/Changing.swift`
 
@@ -171,6 +202,7 @@ additionally compiled and run by `ReadmeExampleTests`
 **Checked by:** matched against the README's "Change what is there" section by
 `Scripts/check_examples.py`; compiled and run through the package's public
 products by `swift test --package-path Examples`
+<!-- /port -->
 
 ### Source inclusion
 
diff --git a/site/src/content/docs/examples/capture-pane-output.md b/site/src/content/docs/examples/capture-pane-output.md
index 80eec2aa..a0b89670 100644
--- a/site/src/content/docs/examples/capture-pane-output.md
+++ b/site/src/content/docs/examples/capture-pane-output.md
@@ -1,6 +1,7 @@
 ---
+supportedPorts: []
 title: Capture pane output
-description: Capture a pane's screen and wait for expected output or a completion signal.
+description: Capture a tmux pane's screen and wait for a complete output line.
 sidebar:
   label: Capture pane output
   group: Examples
@@ -8,225 +9,88 @@ sidebar:
 tableOfContents: true
 ---
 
-Read a pane after [sending input](../attach-and-send-keys/). [Sending
-keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site) explains
-why an immediate capture can miss output. These examples show screen capture and
-waiting; [Capturing output](/guides/capturing-output/) explains the choices. See
-[source details](#where-this-comes-from) for each example's source and
-validation.
+`capture-pane -p` prints a pane's visible screen. Sending a command and reading
+its result are separate operations: the pane's shell may still be processing
+input when the first capture runs.
 
 ## Read what's on screen
 
-```python
->>> pane = window.split(shell='sh')
->>> pane.capture_pane()
-['$']
-
->>> pane.send_keys('echo "Hello world"', enter=True)
-
->>> pane.capture_pane()
-['$ echo "Hello world"', 'Hello world', '$']
-```
-
-```typescript file="examples/capture/capture.ts"
-```
-
-```go
-// From examples/quickstart/main.go, shown in full on Attach and send keys.
-lines, err := pane.Capture(ctx, tmux.CapturePaneRequest{
-	Start: tmux.CaptureBoundary,
-	End:   tmux.CaptureBoundary,
-})
-```
-
-```rust file="crates/libtmux/examples/scratch.rs" region="capture"
-```
-
-```java
-Pane pane = server.sessions().get(0).windows().get(0).panes().get(0);
-
-pane.sendLine("echo hello from libtmux");
-
-pane.capture().isEmpty();            // → false
-```
-
-The .NET example under "Wait for text instead of guessing a delay" uses
-`Pane.CaptureAsync` within a wait. Its separate Psmux transport also provides a
-capture API, shown in `examples/LibTmux.Examples/Snippets/Psmux.cs`.
-
-```cpp
-const auto visible = pane.capture();
-if (visible.has_value()) {
-  std::printf("%zu bytes on screen\n", visible->size());
-}
-
-const auto history = pane.capture({.whole_history = true});
-if (history.has_value()) {
-  std::printf("%zu bytes of scrollback\n", history->size());
-}
-```
-
-```swift
-// From Examples/Sources/ExampleCode/Changing.swift, readBackWhatAPanePrinted: shown in full on Attach and send keys.
-let lines = try await server.capture(pane)
-```
-
-## Wait for text instead of guessing a delay
-
-The Python example uses `wait_for`, tmux's signal channel. It waits for a signal
-from the command rather than matching pane text.
-
-```python
->>> server.new_session(session_name='wait_test')
-Session(...)
->>> server.wait_for('test_channel', set_flag=True)
-```
-
-```typescript file="examples/agent/agent.ts"
-```
-
-```go file="examples/control-mode-subscribe/main.go"
+This complete shell program starts a private tmux server, sends a command, and
+captures until the expected line appears. It removes the server on exit and
+fails after 100 unsuccessful checks with 50-millisecond pauses.
+
+Save it as `capture.sh` and run `sh capture.sh`, or paste the whole block into
+a POSIX shell. It requires tmux 3.2 or newer and `sleep` with fractional seconds.
+
+```sh title="capture.sh"
+(
+    set -eu
+    directory=$(mktemp -d "${TMPDIR:-/tmp}/libtmux-capture.XXXXXX")
+    socket="$directory/tmux.sock"
+    started=0
+
+    cleanup() {
+        status=$?
+        trap - EXIT
+        if [ "$started" = 1 ]; then
+            tmux -S "$socket" kill-server || status=$?
+        fi
+        rm -rf "$directory" || status=$?
+        exit "$status"
+    }
+    trap cleanup EXIT
+    trap 'exit 1' HUP INT TERM
+
+    tmux -S "$socket" -f /dev/null new-session -d -s capture \
+        -e ENV=/dev/null 'sh'
+    started=1
+    tmux -S "$socket" send-keys -t capture:0.0 -l \
+        "printf '\\nlibtmux capture ready\\n'"
+    tmux -S "$socket" send-keys -t capture:0.0 Enter
+
+    attempt=0
+    while [ "$attempt" -lt 100 ]; do
+        screen=$(tmux -S "$socket" capture-pane -p -t capture:0.0)
+        if printf '%s\n' "$screen" | grep -Fqx 'libtmux capture ready'; then
+            printf '%s\n' "$screen"
+            exit 0
+        fi
+        attempt=$((attempt + 1))
+        sleep 0.05
+    done
+    printf '%s\n' 'Timed out waiting for captured output.' >&2
+    exit 1
+)
 ```
 
-`Session.OpenNotifications` receives tmux events as a stream. For tests that
-need to wait for screen text, use `tmuxtest.WaitForText`; see [Testing with
-libtmux](/guides/testing-with-libtmux/).
-
-```rust
-// From crates/libtmux/examples/scratch.rs, the wait_for_text call: shown in full on Attach and send keys.
-match pane.wait_for_text("hello", Duration::from_secs(5)).await? {
-    PaneWait::Arrived => println!("  the pane printed it"),
-    other => println!("  gave up: {other:?}"),
-}
-```
-
-Rust's `wait_for_text` looks before it sleeps, joins wrapped lines so a
-needle spanning a wrap still matches, and returns `PaneWait::Dead` rather
-than hanging forever if the pane's process ends first.
-
-```java file="examples/src/main/java/io/github/libtmux/examples/WatchPaneOutput.java"
-```
-
-Attach the `ControlClient` to receive `%output` notifications. An unattached
-client receives command replies only.
-
-```csharp
-await pane.SendTextAsync("echo hello-from-libtmux", cancellationToken: ct);
-await pane.EnterAsync(ct);
-
-string output = await TmuxWait.UntilAsync(
-    async token => string.Join('\n', await pane.CaptureAsync(cancellationToken: token)),
-    text => text.Contains("hello-from-libtmux", StringComparison.Ordinal),
-    TimeSpan.FromSeconds(10),
-    TimeSpan.FromMilliseconds(20));
-```
-
-`TmuxWait.UntilAsync` polls a read against a predicate rather than sleeping
-a fixed amount.
-
-C++ has no checked snippet that waits on pane *text*. `Server::wait_for(channel,
-timeout)`, in `include/libtmux/server.hpp`, uses tmux's own `wait-for` signal
-instead of scraping output, and its doc comment explains why that is the
-safer choice when the command you are waiting on can be made to announce
-itself: "a server that dies under a waiter makes tmux exit zero, which is
-indistinguishable from being signalled ... this reports that as a failure
-instead."
-
-```swift file="Examples/Sources/ExampleCode/Waiting.swift"
-```
-
-`waitForOutput` takes patterns for both success and failure, so a process
-that fails fast is discovered immediately rather than by timing out.
-
-## Where this comes from
-
-### Python
-
-**Source:** `src/libtmux/pane.py` (`capture_pane`), `src/libtmux/server.py`
-(`wait_for`) docstrings
-
-**In this page:** hand-quoted
-
-**Checked by:** `pytest` runs every `>>>` doctest against a real, isolated tmux
-session on every test run
-
-### TypeScript
-
-**Source:** `examples/capture/capture.ts` (read), `examples/agent/agent.ts`
-(wait)
-
-**In this page:** read whole from each file
-
-**Checked by:** both run against real tmux by `bun test examples`; `agent.ts` is
-additionally mirrored into README.md under a `<!-- runs: ... -->` marker checked
-by `scripts/check-doc-runnable.ts`
-
-### Go
-
-**Source:** `examples/quickstart/main.go` (read, already shown whole on the
-previous page), `examples/control-mode-subscribe/main.go` (wait)
-
-**In this page:** read: hand-quoted; wait: read whole from the file
-
-**Checked by:** both run against real tmux as `TestQuickstart` /
-`TestControlModeSubscribe`; the wait file's `docs:watching` region is
-additionally mirrored into README.md by `go generate ./tmux`
-
-### Rust
-
-**Source:** `crates/libtmux/examples/scratch.rs`, already shown whole on the
-previous page
-
-**In this page:** hand-quoted excerpts of the same file
-
-**Checked by:** run to completion against a throwaway tmux by
-`scripts/run-examples.sh`, which CI runs
-
-### Java
-
-**Source:** root `README.md` Quickstart (read),
-`examples/src/main/java/io/github/libtmux/examples/WatchPaneOutput.java` (wait)
-
-**In this page:** read: hand-quoted; wait: read whole from the file
-
-**Checked by:** every README fence is compiled and run against real tmux by
-`docs-tests`; `WatchPaneOutput` is additionally run by the `examples` module's
-`ExamplesRunTest`
-
-### .NET
-
-**Source:** root `README.md`, "Running something, and reading it back"
-
-**In this page:** hand-quoted
-
-**Checked by:** one of the `csharp run` blocks compiled and run against real
-tmux by `ReadmeExampleTests`
-
-### C++
-
-**Source:** `examples/05-readme.cpp` `capture` region (read);
-`include/libtmux/server.hpp` doc comment (wait, no fence)
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
 
-**In this page:** hand-quoted
+## Wait for output or completion
 
-**Checked by:** the `capture` region is quoted verbatim into README.md and
-checked by `tools/docs/check_readme.py`; the whole file is built and run by
-CTest
+The leading newline puts the output on a fresh screen row even if the shell's
+first prompt arrives late. `grep -Fx` matches the complete line, so the echoed
+command cannot satisfy the check. The short pause limits polling; the captured
+output determines when the program finishes.
 
-### Swift
+Capture reads screen state, so it can miss output that has scrolled away.
+[Capturing output](/guides/capturing-output/) covers history and streaming;
+[Sending keys](/guides/sending-keys/) explains input and completion.
 
-**Source:** `Examples/Sources/ExampleCode/Changing.swift` (read, already shown
-whole on the previous page), `Waiting.swift` (wait)
+## Use a language library
 
-**In this page:** read: hand-quoted excerpt; wait: read whole from the file
+Complete programs with imports, setup, and cleanup:
 
-**Checked by:** both matched against the README by `Scripts/check_examples.py`
-and run by `swift test --package-path Examples`
+[Python](/py/latest/examples/capture-pane-output/) ·
+[TypeScript](/ts/latest/examples/capture-pane-output/) ·
+[Go](/go/latest/examples/capture-pane-output/) ·
+[Rust](/rs/latest/examples/capture-pane-output/) ·
+[Java](/java/latest/examples/capture-pane-output/) ·
+[.NET](/dotnet/latest/examples/capture-pane-output/) ·
+[C++](/cxx/latest/examples/capture-pane-output/) ·
+[Swift](/swift/latest/examples/capture-pane-output/)
 
-### Source inclusion
+<a id="source-inclusion"></a>
+<a id="where-this-comes-from"></a>
 
-Go, Rust, and Swift each reuse a file already shown in full on
-[Attach and send keys](../attach-and-send-keys/#where-this-comes-from):
-rather than dump the same file a second time, this page quotes just the
-relevant lines by hand, with a comment naming the source, and points back
-at the full listing there.
+The [tmux manual source](https://github.com/tmux/tmux/blob/94796f6b1182507efac8a272fc309a79e22e58a5/tmux.1)
+describes `capture-pane`, `send-keys`, and `kill-server`.
diff --git a/site/src/content/docs/examples/index.md b/site/src/content/docs/examples/index.md
index d88ce59e..24f0e8b6 100644
--- a/site/src/content/docs/examples/index.md
+++ b/site/src/content/docs/examples/index.md
@@ -1,20 +1,16 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Examples
-description: Programs for sending input, capturing output, and building workspaces in each language.
+description: Programs for sending input, capturing output, and building workspaces.
 sidebar:
   label: Overview
   group: Examples
   order: 1
 ---
 
-These examples show how to complete a tmux task in each language. Use the tabs
-to select your port. Each page includes the source file and the checks run by
-that port's test suite; see those details before adapting an excerpt into a
-standalone program.
-
-Examples marked with `file=` are read from the port source during the build.
-Other blocks are copied excerpts. The source details identify which mechanism
-each block uses.
+Use these programs to send input, capture output, and build a workspace.
+Each example page includes its source and test coverage. Check those details
+before adapting an excerpt into a standalone program.
 
 - **[Attach and send keys](attach-and-send-keys/)**: get a session, send a
   command, and read output. Uses the hierarchy described in [Server, session,
@@ -22,11 +18,12 @@ each block uses.
 - **[Capture pane output](capture-pane-output/)**: read back what a
   pane is showing, and wait for output to appear instead of guessing a
   delay. The companion to [Capturing output](/guides/capturing-output/).
-- **[Build a workspace from a file](workspace-from-file/)**: the
-  tmuxp-shaped job of describing a multi-window session as data and
-  building it in one call, in each port that has one.
+- **[Build a workspace from a file](workspace-from-file/)**: describe a session as
+  configuration and create its windows and panes.
+
+<a id="what-verified-means-per-port"></a>
 
-## What "verified" means, per port
+## Source and verification
 
 Port repositories use the following checks for their source examples. This site
 reads or copies those examples; a successful site build alone does not execute
@@ -34,15 +31,15 @@ them:
 
 | Port | Mechanism | What it checks |
 |------|-----------|-----------------|
-| Python | `pytest` `testpaths` includes `README.md` and `src/libtmux` | `>>>` doctest blocks run against a real, isolated tmux session on every test run |
-| TypeScript | `scripts/check-doc-runnable.ts` | A block tagged `<!-- runs: examples/foo.ts -->` must appear, line for line, in that file, which the integration suite executes |
-| Go | `go generate ./tmux` (`internal/generate/docs`) | A `<!-- docs:name -->` region in `README.md` is rewritten from the matching `// docs:name` … `// docs:end` region in `examples/`; CI fails on drift |
-| Rust | `#![doc = include_str!("../README.md")]` | The entire README is a doc comment, so `cargo test --doc` compiles and runs every fenced Rust block in it |
-| Java | `docs-tests` (`./gradlew :docs-tests:test`) | Every Java fence in READMEs and guides is compiled against the real artifacts, then run against real tmux via `libtmux-junit5` |
-| .NET | `sync_snippets.py --check` + `ReadmeExampleTests` | A `<!-- snippet: Name -->` region is quoted from a tested `[Example]` method; every `csharp run` block is additionally compiled and executed |
-| C++ | `tools/docs/check_readme.py` | Each ` ```cpp ` block in `README.md` must appear verbatim as a `#region` in `examples/05-readme.cpp`, which CTest builds and runs |
-| Swift | `Scripts/check_examples.py` | Each ` ```swift ` block in `README.md` and product READMEs must appear in `Examples/Sources/`, which `swift test --package-path Examples` compiles through its public products |
-
+<!-- port:py -->| Python | `pytest` `testpaths` includes `README.md` and `src/libtmux` | `>>>` doctest blocks run against a real, isolated tmux session on every test run |
+<!-- /port --><!-- port:ts -->| TypeScript | `scripts/check-doc-runnable.ts` | A block tagged `<!-- runs: examples/foo.ts -->` must appear, line for line, in that file, which the integration suite executes |
+<!-- /port --><!-- port:go -->| Go | `go generate ./tmux` (`internal/generate/docs`) | A `<!-- docs:name -->` region in `README.md` is rewritten from the matching `// docs:name` … `// docs:end` region in `examples/`; CI fails on drift |
+<!-- /port --><!-- port:rs -->| Rust | `#![doc = include_str!("../README.md")]` | The entire README is a doc comment, so `cargo test --doc` compiles and runs every fenced Rust block in it |
+<!-- /port --><!-- port:java -->| Java | `docs-tests` (`./gradlew :docs-tests:test`) | Every Java fence in READMEs and guides is compiled against the real artifacts, then run against real tmux via `libtmux-junit5` |
+<!-- /port --><!-- port:dotnet -->| .NET | `sync_snippets.py --check` + `ReadmeExampleTests` | A `<!-- snippet: Name -->` region is quoted from a tested `[Example]` method; every `csharp run` block is additionally compiled and executed |
+<!-- /port --><!-- port:cxx -->| C++ | `tools/docs/check_readme.py` | Each ` ```cpp ` block in `README.md` must appear verbatim as a `#region` in `examples/05-readme.cpp`, which CTest builds and runs |
+<!-- /port --><!-- port:swift -->| Swift | `Scripts/check_examples.py` | Each ` ```swift ` block in `README.md` and product READMEs must appear in `Examples/Sources/`, which `swift test --package-path Examples` compiles through its public products |
+<!-- /port -->
 See [Testing with libtmux](/guides/testing-with-libtmux/) for the fixture
 each of those test suites runs against, and each example page below for the
 exact file a given snippet was quoted from.
diff --git a/site/src/content/docs/examples/workspace-from-file.md b/site/src/content/docs/examples/workspace-from-file.md
index c8cd6613..5d00c163 100644
--- a/site/src/content/docs/examples/workspace-from-file.md
+++ b/site/src/content/docs/examples/workspace-from-file.md
@@ -1,6 +1,7 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Build a workspace from a file
-description: The tmuxp-shaped job of describing a multi-window session as data and building it in one call, in each port that has a checked way to do it.
+description: Describe a session in configuration, validate it, and build its windows and panes.
 sidebar:
   label: Build a workspace from a file
   group: Examples
@@ -9,22 +10,27 @@ tableOfContents: true
 ---
 
 [tmuxp](https://tmuxp.git-pull.com/) describes sessions, windows, panes, and
-shell commands in configuration files. Several libtmux ports provide builders
-for this format. [Source details](#where-this-comes-from) identify the example
+shell commands in configuration files. A workspace builder turns that
+configuration into tmux objects. [Source details](#where-this-comes-from) identify the example
 files and their checks.
 
+<!-- port:py -->
 For Python, use [tmuxp](https://tmuxp.git-pull.com/), a separate application
 built on libtmux's `Server`, `Session`, `Window`, and `Pane` APIs.
+<!-- /port -->
 
 ```typescript file="examples/workspace/workspace.ts"
 ```
 
+<!-- port:ts -->
 TypeScript's `applyWorkspace` reuses existing objects when the same
 configuration is applied again.
+<!-- /port -->
 
 ```go file="workspace/example_test.go"
 ```
 
+<!-- port:go -->
 Go's `Example()`, in `workspace/example_test.go`, is a Go `Example`
 function: `go test` runs it and checks its output against the
 `// Output:` comment at the end, so this is executed on every test run
@@ -33,6 +39,7 @@ recognize rather than dropping it silently, and reports every problem it
 finds at once with the line it's on. `Build` is not atomic: tmux has no
 transaction, so a failure partway through leaves whatever was already
 created in place, identified by the session `Build` still returns.
+<!-- /port -->
 
 ```rust
 use libtmux::test::TestServer;
@@ -53,9 +60,11 @@ assert_eq!(session.name().to_string_lossy(), "dev");
 assert_eq!(session.windows().await?.len(), 1);
 ```
 
+<!-- port:rs -->
 Rust's `freeze(&session).await?` exports an existing session to the workspace
 format. It recovers windows, panes, and working directories, but cannot recover
 the shell command originally typed to start a process.
+<!-- /port -->
 
 ```java
 Workspace workspace = WorkspaceBuilder.parse("""
@@ -78,8 +87,10 @@ session.windows().size();                         // → 2
 session.windows().get(0).panes().size();          // → 2
 ```
 
+<!-- port:java -->
 Java's `read` and `parse` validate the configuration and return a `Workspace`
 value. Only `build` changes tmux state.
+<!-- /port -->
 
 ```csharp
 WorkspaceFile workspace = WorkspaceFile.Parse("""
@@ -98,6 +109,7 @@ WorkspaceResult result = await new WorkspaceBuilder(server).BuildAsync(workspace
 Console.WriteLine($"{result.Session.Name}: {result.Windows.Count} windows");
 ```
 
+<!-- port:dotnet -->
 The .NET builder can wait for shell readiness before sending commands; [Sending
 keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site) explains
 the startup race. It polls `pane_current_command`, `cursor_x`, and `cursor_y`
@@ -105,23 +117,31 @@ for up to ten seconds by default. `PaneReadiness.Auto` waits for zsh, `Always`
 waits for every pane running the session's default shell, and `Never` sends
 immediately. If `BuildAsync` fails partway through,
 `WorkspaceBuildException.PartialResult` identifies what was created.
+<!-- /port -->
 
+<!-- port:cxx -->
 C++'s `examples/workspace/` implements a consumer of the core API with its own
 `workspace.hpp` and `tmuxp.hpp` types. Those types are part of the example, not
 the library package. See [the example's
 README](https://github.com/libtmux/libtmux-cxx/tree/main/examples/workspace) to
 adapt it.
+<!-- /port -->
 
 ```swift file="Examples/Sources/ExampleCode/Workspaces.swift"
 ```
 
+<!-- port:swift -->
 Swift's `WorkspaceBuilder.build` rejects an existing session with the requested
 name. `Workspace.decode(yaml:)` reads tmuxp YAML when the `YAMLWorkspaces` trait
 is enabled. `Workspace.decode(json:)` needs no additional trait.
+<!-- /port -->
 
 ## Where this comes from
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 **Source:** Not listed.
 
@@ -129,16 +149,24 @@ is enabled. `Workspace.decode(json:)` needs no additional trait.
 design
 
 **Checked by:** n/a
+<!-- /port -->
 
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 **Source:** `examples/workspace/workspace.ts` (`@libtmux/workspace`)
 
 **In this page:** read whole from the file
 
 **Checked by:** run against real tmux by `bun test examples/workspace`
+<!-- /port -->
 
+<!-- port:go -->
+<!-- port:root -->
 ### Go
+<!-- /port -->
 
 **Source:** `workspace/example_test.go` (`workspace.Parse` / `workspace.Build`)
 
@@ -146,8 +174,12 @@ design
 
 **Checked by:** `Example()` and its siblings run under `go test` and are checked
 against their own `// Output:` comments
+<!-- /port -->
 
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 **Source:** `crates/tmux-workspace/README.md`, "Build it"
 
@@ -156,8 +188,12 @@ against their own `// Output:` comments
 **Checked by:** the crate's own `crates/tmux-workspace/src/lib.rs` includes the
 README as a doc comment (`#![doc = include_str!("../README.md")]`), so `cargo
 test --doc` runs this exact block
+<!-- /port -->
 
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
 **Source:** `libtmux-workspace/README.md`, "What you get back"
 
@@ -165,8 +201,12 @@ test --doc` runs this exact block
 
 **Checked by:** every Java fence in the module's README is compiled and run
 against real tmux by `docs-tests`
+<!-- /port -->
 
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 **Source:** `src/LibTmux.Workspace/README.md`
 
@@ -174,8 +214,12 @@ against real tmux by `docs-tests`
 
 **Checked by:** one of the READMEs and docs `ReadmeExampleTests` compiles and
 runs against real tmux
+<!-- /port -->
 
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
 **Source:** `examples/workspace/` (a consumer, not a library API)
 
@@ -184,8 +228,12 @@ runs against real tmux
 **Checked by:** `examples/workspace/tests/` runs the consumer suite against
 real tmux; `ctest -R consumer.workspace` selects it. It exercises the
 example's own types, not a published `libtmux` API
+<!-- /port -->
 
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 **Source:** `Examples/Sources/ExampleCode/Workspaces.swift`
 
@@ -194,8 +242,9 @@ example's own types, not a published `libtmux` API
 **Checked by:** matched against the README's "Workspaces, from a file or from
 Swift" section by `Scripts/check_examples.py`; compiled and run by `swift test
 --package-path Examples`
+<!-- /port -->
 
 ### Source inclusion
 
-Rust, Java, and .NET use copied excerpts from their README examples. The source
+Some blocks are excerpts from tested README examples. The source
 details above identify those files and their checks.
diff --git a/site/src/content/docs/guides/attaching-to-tmux.md b/site/src/content/docs/guides/attaching-to-tmux.md
index 712660af..e3e3d53e 100644
--- a/site/src/content/docs/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/guides/attaching-to-tmux.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Attaching to tmux
 description: What a plain constructor call actually connects to, and how to find a session that might already exist instead of always creating a new one.
 sidebar:
@@ -13,10 +14,12 @@ process keeps its own stdin and stdout, and tmux continues running
 independently. [Attach and send keys](/examples/attach-and-send-keys/)
 demonstrates this workflow.
 
+<!-- port:py -->
 Attaching your terminal is a separate operation. Python's `Session.attach()`
 runs `tmux attach-session` and hands the terminal to tmux.
 [tmuxp](https://tmuxp.git-pull.com/) uses it after building a workspace. Check
 your port's reference if your program needs to hand over the terminal.
+<!-- /port -->
 
 ## Which socket a bare constructor reaches
 
@@ -36,8 +39,7 @@ server = libtmux.Server.from_env()
 ```
 
 ```typescript
-// Behaves like the other ports' bare form. Naming a socket wasn't confirmed
-// against a checked snippet for this page: check the port's own reference.
+// Select the default tmux socket.
 const server = new Server();
 ```
 
@@ -47,6 +49,9 @@ const server = new Server();
 // if both are set); a Server built this way does not drift if the
 // environment changes later.
 server, err := tmux.NewServer(tmux.ServerOptions{})
+if err != nil {
+    return err
+}
 ```
 
 ```rust
@@ -72,7 +77,7 @@ TmuxEnvironment.current();
 Server server = await Server.ConnectAsync();
 
 // The separate pane-local read-back; ConnectAsync never consults TMUX.
-Server fromPane = await Server.FromEnvironment();
+Server fromPane = Server.FromEnvironment();
 ```
 
 ```cpp
@@ -85,22 +90,12 @@ libtmux::Server::at_default();        // "my tmux", to a person
 ```
 
 ```swift
-// The literal quickstart: there is no bare no-argument constructor, so
-// naming the socket is not optional the way it is elsewhere.
+// Select the default tmux socket explicitly.
 let server = try Server(socketName: "default")
 ```
 
-Sources: Python's `Server.from_env()` is doctested in `src/libtmux/server.py`
-(`pyproject.toml` `testpaths`). .NET's resolution order and `FromEnvironment`
-are from `src/LibTmux/README.md` ("Where a bare connect lands"), one of the
-nine documents `ReadmeExampleTests` compiles and runs. Go's is
-`tmux/server_options.go`'s doc comments. Rust's fallback is
-`crates/libtmux/examples/find.rs`, run via `cargo run --example find`. C++'s
-four constructors are the README's own description of `Server`, at the top
-of "What is libtmux?". Swift's is `README.md`'s top-level quickstart,
-matched against `Examples/Sources/QuickStart/main.swift` by
-`Scripts/check_examples.py`. Java's is `README.md`, run by
-[`docs-tests`](../testing-with-libtmux/#java-docs-tests).
+[Socket and servers](/topics/socket-and-servers/) covers endpoint selection
+and liveness. [Environment](/topics/environment/) covers pane-local lookup.
 
 ## Finding a session instead of always creating one
 
@@ -127,6 +122,10 @@ const session = snapshot.sessions.where({ name: "demo" }).oneOrUndefined();
 // everything back and filtering in the process.
 live := tmux.TmuxFilter("#{==:#{session_name},demo}")
 sessions, err := server.SearchSessions(ctx, &live)
+if err != nil {
+    return err
+}
+fmt.Println("matching sessions:", len(sessions))
 ```
 
 ```java
@@ -146,20 +145,18 @@ if try await server.hasSession("work") == false {
 }
 ```
 
-Sources: Go uses `examples/filter-query/main.go`, region `docs:query-in-tmux`.
-Java uses `examples/.../BuildAWorkspace.java`, run by the examples module's
-tests. For exactly-one lookup semantics, see [Filtering and querying, in
-practice](../querying-and-filtering/). Swift uses
-`Examples/Sources/ExampleCode/Querying.swift`, checked against the README by
-`Scripts/check_examples.py` and exercised by
-`Examples/Tests/ExampleTests/ModeTests.swift`.
-
-.NET exposes `Server.HasSessionAsync(name)` in
-`src/LibTmux/Server.Lifecycle.cs`. Its `CreateSessionAsync` supports
-`ReplaceExisting`, which kills and recreates the session. Rust and C++ provide
-query APIs for session lookup. See [Filtering and querying, in
-practice](../querying-and-filtering/) and the port references for the call
-signatures; this page has no tested excerpt for those combinations.
+<!-- port:dotnet -->
+`Server.HasSessionAsync(name)` checks for a session. Use `NewSessionRequest.ReplaceExisting`
+with `Server.CreateSessionAsync` only when killing and recreating it is intended.
+<!-- /port -->
+
+Finding an object and creating one are separate operations. Another client
+can change tmux state between them. Handle the creation error if the name was
+taken after the lookup.
+
+[Filtering and querying](../querying-and-filtering/) covers absent and
+ambiguous matches. [Attach and send keys](/examples/attach-and-send-keys/)
+contains complete programs and their source details.
 
 ## Where to go next
 
diff --git a/site/src/content/docs/guides/capturing-output.md b/site/src/content/docs/guides/capturing-output.md
index 91e748e3..f209bfc6 100644
--- a/site/src/content/docs/guides/capturing-output.md
+++ b/site/src/content/docs/guides/capturing-output.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Capturing output
 description: Read a pane's screen or scrollback and wait for output or a completion signal.
 sidebar:
@@ -15,8 +16,7 @@ before reading the result.
 ## Visible pane vs. scrollback
 
 `tmux capture-pane` distinguishes the currently visible screen from the
-scrollback history above it, and every port exposes that split rather than
-flattening it:
+scrollback history above it. Choose the range required by your task:
 
 ```python
 # 0 is the first visible line; positive numbers stay in the visible pane;
@@ -34,11 +34,16 @@ const lines = await pane.capture({ start: -100 });
 ```
 
 ```go
-// Same boundary vocabulary as Python's. CaptureBoundary on both ends means
-// "just the visible screen."
+// Include scrollback from its beginning through the bottom of the screen.
 lines, err := pane.Capture(ctx, tmux.CapturePaneRequest{
 	Start: tmux.CaptureBoundary, End: tmux.CaptureBoundary,
 })
+if err != nil {
+    return err
+}
+for _, line := range lines {
+    fmt.Println(line)
+}
 ```
 
 ```rust
@@ -60,16 +65,15 @@ const auto history = pane.capture({.whole_history = true});
 let lines = try await server.capture(pane)
 ```
 
-Java's `pane.capture()` and .NET's `pane.CaptureAsync()` return the visible
-pane as a list of lines; neither's own README shows a scrollback option as
-of this page, so check the port's reference before assuming one exists.
-Sources: TypeScript's is `examples/capture/capture.ts`, run by `bun test
-examples/capture`. Go's is `examples/quickstart/main.go`. Rust's is
-`crates/libtmux/README.md`'s capability table, doctested via `#![doc =
-include_str!("../README.md")]`. C++'s is `README.md`'s "Read a pane"
-section, quoted verbatim from `examples/05-readme.cpp`'s `capture` region
-and checked by `tools/docs/check_readme.py`. Swift's is `README.md`,
-"Change what is there."
+<!-- port:java -->
+`pane.capture()` returns visible pane contents as a list of lines.
+<!-- /port -->
+<!-- port:dotnet -->
+`pane.CaptureAsync()` returns visible pane contents as a list of lines.
+<!-- /port -->
+
+[Capture pane output](/examples/capture-pane-output/) includes complete
+programs and source details.
 
 <a id="dont-poll-wait-for-the-text-instead"></a>
 
@@ -133,24 +137,18 @@ string output = await TmuxWait.UntilAsync(
 try await server.waitForOutput(in: pane, matching: [ready], stoppingAt: [failed])
 ```
 
-Python's pytest plugin supplies isolated test servers; see [Testing with
-libtmux](../testing-with-libtmux/). For Python and C++ signal-based waiting, use
-the `wait-for` APIs below. This page does not include a wait-for-text helper for
-those ports.
-
-Sources: Go's is `tmux/tmuxtest/screen.go`, quoted in `README.md`'s "Testing
-your own code" section. Rust's is `crates/libtmux/README.md`, doctested.
-TypeScript's is `examples/agent/agent.ts`, run by the integration suite and
-quoted in `packages/libtmux/README.md` (`<!-- runs: examples/agent/agent.ts
--->`). Java's is `examples/.../WatchPaneOutput.java`. .NET's is `README.md`,
-one of the `csharp run` blocks `ReadmeExampleTests` runs. Swift's is
-`Examples/Sources/ExampleCode/Waiting.swift`, matched against
-`<doc:Waiting>` and the README by `Scripts/check_examples.py`; the same
-file's `server.capture(pane, since: mark)`, called in a loop with the cursor
-it returns, is the "watch as it prints" shape for output too large or too
-open-ended to wait on a single pattern.
-
-## When the pane can announce itself: `wait-for`, not scraping
+<!-- port:py,cxx -->
+Use a completion channel when the program can announce that its work is done.
+The next section explains that protocol.
+<!-- /port -->
+
+[Testing with libtmux](../testing-with-libtmux/) explains isolated servers
+and fixtures. [Capture pane output](/examples/capture-pane-output/) provides
+the full examples.
+
+<a id="when-the-pane-can-announce-itself-wait-for-not-scraping"></a>
+
+## Wait for a completion signal
 
 If you control the command, have it signal completion with `tmux wait-for -S
 done`. Wait on the same channel to avoid matching screen text:
@@ -161,18 +159,27 @@ Session(...)
 >>> server.wait_for('test_channel', set_flag=True)
 ```
 
-The Python example is a doctest in `src/libtmux/server.py`. C++'s
-`Server::wait_for(channel, timeout)`, declared in `include/libtmux/server.hpp`,
-also detects a server that dies during the wait. Swift's `server.wait(for:)`
-example waits for a build to signal completion:
+<!-- port:cxx -->
+`Server::wait_for(channel, timeout)` also detects a server that dies during
+the wait and reports failure.
+<!-- /port -->
 
-```swift file="Examples/Sources/ExampleCode/Waiting.swift" region="guides-capturing-output-176"
+```swift
+import LibTmux
+
+public func waitingOnAChannel(_ server: Server, pane: Pane) async throws {
+    try await server.run(
+        "make; \(server.shellInvocation) wait-for -S built",
+        in: pane
+    )
+    try await server.wait(for: "built")
+}
 ```
 
-Source: `Examples/Sources/ExampleCode/Waiting.swift`. Rust's
-`crates/libtmux/README.md` documents the same pattern under "tmux keeps a
-signal nobody is waiting on, so the job finishing first does not lose the
-race, and nothing polls," runnable as `examples/orchestrate.rs`.
+Use a distinct channel name for each task. tmux remembers a signal sent before
+a waiter starts; reusing a signalled name can therefore finish an unrelated
+later wait. [Waiting and retrying](/topics/waiting-and-retry/) covers channel
+APIs and server-loss handling.
 
 ## Where to go next
 
diff --git a/site/src/content/docs/guides/getting-started.md b/site/src/content/docs/guides/getting-started.md
index e9d5c03d..6b80d530 100644
--- a/site/src/content/docs/guides/getting-started.md
+++ b/site/src/content/docs/guides/getting-started.md
@@ -1,6 +1,7 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Getting started
-description: Install tmux, pick a port, and run the smallest thing that proves your setup works.
+description: Install tmux and the library, then create a session and interact with a pane.
 sidebar:
   label: Getting started
   group: Guides
@@ -21,6 +22,7 @@ $ tmux -V
 If `tmux` is missing or older than 3.2a, install a supported version with your
 platform's package manager. libtmux uses an installed tmux executable.
 
+<!-- port:root -->
 ## Pick a port
 
 Choose the port for your project's language: [Python](/py/), [TypeScript](/ts/),
@@ -30,21 +32,24 @@ pane](/concepts/server-session-window-pane/) explains the shared model, and
 [Control mode vs one-shot](/concepts/transports/) covers transport differences.
 
 For a prerelease package, pin an exact version and check its release notes
-before upgrading. API availability and defaults can differ between ports.
+before upgrading. Check the package version's API reference for supported operations.
+<!-- /port -->
 
 ## Run the smallest thing that proves it works
 
-Start a tmux session to connect to: in one terminal:
+<!-- port:py -->
+Start a tmux session in one terminal:
 
 ```console
 $ tmux new-session -s foo -n bar
 ```
 
-In a second terminal, install your port's package and run its example. The
-Python example uses the `foo` session above; the other examples create their own
-sessions. Installation commands appear in comments at the start of each block.
-[Attach and send keys](/examples/attach-and-send-keys/) provides the full
-examples, their source files, and their validation details.
+Run the example in a second terminal. It uses the session you just created.
+<!-- /port -->
+
+Install the package using the command shown with its example.
+[Attach and send keys](/examples/attach-and-send-keys/) contains the complete
+program, prerequisites, and source details.
 
 ```python
 # pip install libtmux
diff --git a/site/src/content/docs/guides/index.md b/site/src/content/docs/guides/index.md
index e9977455..cbfda341 100644
--- a/site/src/content/docs/guides/index.md
+++ b/site/src/content/docs/guides/index.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Guides
 description: Task-oriented walkthroughs that sit between the concepts and each port's own API reference.
 sidebar:
@@ -11,7 +12,7 @@ Use these guides to connect to tmux, send input, capture output, query objects,
 and test your program. [Concepts](/concepts/) explains the object model and
 transport choices.
 
-- **[Getting started](getting-started/)**: install tmux, choose a port, and run
+- **[Getting started](getting-started/)**: install tmux and the library, then run
   an example.
 - **[Attaching to tmux](attaching-to-tmux/)**: select a socket and find or
   create a session.
diff --git a/site/src/content/docs/guides/querying-and-filtering.md b/site/src/content/docs/guides/querying-and-filtering.md
index 8699e180..a5ac6b0c 100644
--- a/site/src/content/docs/guides/querying-and-filtering.md
+++ b/site/src/content/docs/guides/querying-and-filtering.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Filtering and querying, in practice
 description: Filter tmux objects, require one match, and choose where a query runs.
 sidebar:
@@ -13,25 +14,36 @@ lookups. [Filtering and queries](/concepts/queries/) explains the result-count
 contracts and the choice between local and tmux-side filtering. This guide adds
 examples for common queries.
 
-## Filling in the rest of the cardinality table
+<a id="filling-in-the-rest-of-the-cardinality-table"></a>
 
+## Require exactly one match
+
+<!-- port:go,rs,cxx -->
 | Port | Collection filter | Exactly-one | Empty | Several |
 |------|--------------------|--------------|-------|---------|
-| Go | `tmuxq.Where(values, predicate)` | `tmuxq.ExactlyOne(values, predicate)` | `tmuxq.ErrNoMatch` | `tmuxq.ErrMultipleMatches` |
-| Rust | `.iter().matching(&expr)` | `.exactly_one()` | prints via the error's `Display` | same, one error type covers both |
-| C++ | pipe a range into [`libtmux::matching(expr)`](/cxx/latest/reference/libtmux-matching/) | `libtmux::exactly_one(range)` | `.error()` says which way it went wrong | same call, same error type |
+<!-- port:go -->| Go | `tmuxq.Where(values, predicate)` | `tmuxq.ExactlyOne(values, predicate)` | `tmuxq.ErrNoMatch` | `tmuxq.ErrMultipleMatches` |
+<!-- /port --><!-- port:rs -->| Rust | `.iter().matching(&expr)` | `.exactly_one()` | prints via the error's `Display` | same, one error type covers both |
+<!-- /port --><!-- port:cxx -->| C++ | pipe a range into [`libtmux::matching(expr)`](/cxx/latest/reference/libtmux-matching/) | `libtmux::exactly_one(range)` | `.error()` says which way it went wrong | same call, same error type |
+<!-- /port -->
+<!-- /port -->
 
-Go's `ExampleExactlyOne` in `tmuxq/example_test.go` checks the result with `go
-test` and `// Output:` assertions:
+<!-- port:go -->
+`tmuxq.ExactlyOne` returns `ErrNoMatch` for no matches and
+`ErrMultipleMatches` for an ambiguous result. Keep the error when wrapping it:
 
 ```go
-_, err := tmuxq.ExactlyOne(noActivePanes, func(pane *pane) bool { return pane.active })
-// errors.Is(err, tmuxq.ErrNoMatch) → true
-
-_, err = tmuxq.ExactlyOne(multipleActivePanes, func(pane *pane) bool { return pane.active })
-// errors.Is(err, tmuxq.ErrMultipleMatches) → true
+pane, err := tmuxq.ExactlyOne(snapshot.Panes(), func(pane *tmux.Pane) bool {
+    name, present := pane.CurrentCommand()
+    return present && name == "nvim"
+})
+if err != nil {
+    return fmt.Errorf("find one editor pane: %w", err)
+}
+fmt.Println("editor pane:", pane.ID())
 ```
+<!-- /port -->
 
+<!-- port:rs -->
 Rust's is `examples/find.rs`, run via `cargo run --example find`:
 
 ```rust
@@ -40,7 +52,9 @@ match panes.iter().matching(&running).exactly_one() {
     Err(error) => println!("not exactly one: {error}"),
 }
 ```
+<!-- /port -->
 
+<!-- port:cxx -->
 C++'s is quoted straight from `examples/05-readme.cpp`'s `cardinality`
 region into `README.md`, and `tools/docs/check_readme.py` fails the build
 if the two ever disagree:
@@ -51,18 +65,29 @@ if (const auto one = libtmux::exactly_one(addressed); one.has_value()) {
     std::printf("exactly one: %s\n", std::string{one->get().id()}.c_str());
 }
 ```
-
-For .NET and Swift result-count handling, consult the port reference. The
-examples here demonstrate .NET's `IEnumerable<T>.Matching<T>(expression)`
-returning an `IReadOnlyList<Session>` and Swift's `hasSession(_:)` returning a
-`Bool`. The latter checks existence; see [Attaching to
-tmux](../attaching-to-tmux/#finding-a-session-instead-of-always-creating-one).
-
-## Declarative filters that travel, beyond Python and TypeScript
-
-[Filtering and queries](/concepts/queries/) covers Python's `.filter()`
-lookups and TypeScript's `.where()` documents. Two more ports build the same
-"a query is data, not code" idea, verified against their own README:
+<!-- /port -->
+
+<!-- port:dotnet -->
+`IEnumerable<T>.Matching<T>(expression)` returns all matching objects.
+Choose an exactly-one operation only when an absent or ambiguous target should
+stop the task.
+<!-- /port -->
+<!-- port:swift -->
+`hasSession(_:)` checks existence. It does not select a single matching object.
+See [Attaching to tmux](../attaching-to-tmux/).
+<!-- /port -->
+<!-- port:py,ts,java -->
+[Filtering and queries](/concepts/queries/) describes the exactly-one method
+and its missing- or multiple-match errors.
+<!-- /port -->
+
+<!-- port:dotnet,swift -->
+<a id="declarative-filters-that-travel-beyond-python-and-typescript"></a>
+
+## Declarative filters
+
+A query document can be stored in configuration and evaluated against captured
+objects. It does not contain an arbitrary callback.
 
 ```csharp
 // Turns a LINQ expression into a portable QueryDocument (or throws),
@@ -79,11 +104,9 @@ IReadOnlyList<Session> building = sessions.Matching<Session>(
 // and it holds no closures, so it encodes for an MCP tool call.
 let expression = FilterExpr<Pane>.where(\.currentCommand, .isIn(["nvim", "vim"]))
 ```
+<!-- /port -->
 
-Sources: .NET's is `src/LibTmux/README.md`, "Filtering." Swift's is
-`Examples/Sources/ExampleCode/Filtering.swift`, matched against the README
-by `Scripts/check_examples.py`.
-
+<!-- port:py,ts,go,swift -->
 ## Case-insensitive matching
 
 ```python
@@ -102,20 +125,26 @@ let editors = try RegexPattern("^(n?vim|hx)$", options: [.caseInsensitive])
 let expression = FilterExpr<Pane>.where(\.currentCommand, .matches(editors))
 ```
 
-For case-insensitive matching in Java, .NET, Go, Rust, and C++, consult the port
-reference. Sources for the examples above: Python's lookup is covered in
-[Filtering and queries](../../concepts/queries/); TypeScript's is in
-`README.md`, "What querying looks like"; Swift's is in
-`Examples/Sources/ExampleCode/Filtering.swift`.
+<!-- port:go -->
+Use a predicate with `strings.EqualFold` for case-insensitive equality:
+
+```go
+matches := tmuxq.Where(snapshot.Sessions(), func(session *tmux.Session) bool {
+    name, present := session.Name()
+    return present && strings.EqualFold(name, "api")
+})
+fmt.Println("matching sessions:", len(matches))
+```
+<!-- /port -->
+
+<!-- /port -->
 
 ## Push the filter into tmux, or read once and filter locally
 
 Use a tmux-side filter to reduce the rows returned, or query a snapshot when you
 need several answers from one read. [Filtering and queries](/concepts/queries/)
-compares Python's `search_sessions()` with `.filter()`, and Go's `SearchPanes`
-with a snapshot plus `tmuxq.Where`. Check the required tmux version. Unknown
-format tokens expand to empty values, so validate an unexpectedly empty search
-before concluding that no objects match.
+explains that choice. Unknown format tokens expand to empty values, so
+validate an unexpectedly empty search before concluding that no objects match.
 
 ## Where to go next
 
diff --git a/site/src/content/docs/guides/sending-keys.md b/site/src/content/docs/guides/sending-keys.md
index 84dbfcbb..f525c647 100644
--- a/site/src/content/docs/guides/sending-keys.md
+++ b/site/src/content/docs/guides/sending-keys.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Sending keys
 description: Literal text versus tmux key names, whether Enter is pressed for you, and why a command can outrun the shell about to run it.
 sidebar:
@@ -37,12 +38,15 @@ await pane.sendKeys("q", { enter: false, literal: true });
 ```
 
 ```go
-// Literal disables tmux key-name lookup and treats Command as literal
-// UTF-8. It does not bypass interpretation by the pane's own shell.
-err := pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &cmd, Literal: true})
-
-// A separate Enter follows Command unless SkipEnter is set.
-err = pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &cmd, SkipEnter: true})
+command := "printf 'ready\\n'"
+if err := pane.SendKeys(ctx, tmux.SendKeysRequest{
+    Command: &command, Literal: true, SkipEnter: true,
+}); err != nil {
+    return err
+}
+if err := pane.Enter(ctx); err != nil {
+    return err
+}
 ```
 
 ```rust
@@ -84,22 +88,25 @@ pane.sendLine("echo hey");
 try await server.run("echo hey", in: pane)
 ```
 
-Check each method's input contract before sending text that could be a key name.
-Some ports separate text and key-name methods; others use a literal-text flag.
+Literal input disables tmux's key-name lookup. The program inside the pane
+still interprets that input, including shell quoting and expansions.
 [Concepts](/concepts/) introduces the shared tmux model.
 
 ## The race you can't see from the call site
 
 Completing `send-keys` means tmux accepted the input. The shell may still be
-starting, and the command may still be running. The port examples provide
-different ways to wait:
-
-- **Rust** uses a `retry_until` loop in the README's query example to wait for
-  the shell.
-- **Go** provides `tmuxtest.WaitForShellReady` for tests that need a ready
-  shell.
-- **.NET** demonstrates waiting for command output in the README's "Running
-  something, and reading it back" section.
+starting, and the command may still be running. Use a wait that checks the state your next operation requires.
+
+<!-- port:rs -->
+Use a bounded `retry_until` loop when shell startup can discard early input.
+<!-- /port -->
+<!-- port:go -->
+`tmuxtest.WaitForShellReady` waits for a ready shell in tests. It does not wait
+for a submitted command to finish.
+<!-- /port -->
+<!-- port:dotnet -->
+Use an output predicate with `TmuxWait.UntilAsync` to wait for a command result.
+<!-- /port -->
 
 Wait for shell readiness before sending input when startup matters. Then wait
 for the command's expected output or a completion signal before reading its
diff --git a/site/src/content/docs/guides/testing-with-libtmux.md b/site/src/content/docs/guides/testing-with-libtmux.md
index 2ff34e3e..0df75e9f 100644
--- a/site/src/content/docs/guides/testing-with-libtmux.md
+++ b/site/src/content/docs/guides/testing-with-libtmux.md
@@ -1,6 +1,7 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Testing with libtmux
-description: Every port ships a way to give your own tests a real, disposable tmux server. What each one hands you, and what it guarantees about cleanup.
+description: Test against a private tmux server and clean up its sessions and socket.
 sidebar:
   label: Testing with libtmux
   group: Guides
@@ -10,9 +11,10 @@ tableOfContents: true
 
 Use a private tmux server to test code that creates sessions, sends input, or
 captures output. The fixtures below allocate a separate socket and manage normal
-test cleanup. Cleanup after abrupt process termination depends on the fixture;
-Java's stale-server cleanup is described below.
+test cleanup. Give each test suite its own socket so it cannot target a
+developer's existing sessions.
 
+<!-- port:py -->
 Request the fixture to obtain its server. Python's `session` fixture depends on
 `server`, so requesting a session also creates an isolated server:
 
@@ -30,21 +32,42 @@ overrides how the fixture builds a session (window size, for instance)
 without forking it; a temporary `HOME` and tmux config keep window and pane
 indices stable across machines, so an assertion like `window_name == "test"`
 doesn't depend on whatever `.tmux.conf` the test runner happens to have.
+<!-- /port -->
 
+<!-- port:go -->
 ```go
-pane := tmuxtest.RunInPane(ctx, t, "printf 'ready\\n'; cat")
+package example_test
 
-tmuxtest.WaitForText(ctx, t, pane, "ready")
-tmuxtest.Type(ctx, t, pane, "a line for the program")
-tmuxtest.WaitForLine(ctx, t, pane, "a line for the program")
+import (
+    "context"
+    "os"
+    "testing"
+    "time"
+
+    "github.com/libtmux/libtmux-go/tmux/tmuxtest"
+)
+
+func TestMain(m *testing.M) {
+    os.Exit(tmuxtest.Main(m))
+}
+
+func TestProgram(t *testing.T) {
+    ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
+    defer cancel()
+    pane := tmuxtest.RunInPane(ctx, t, "printf 'ready\\n'; cat")
+    tmuxtest.WaitForLine(ctx, t, pane, "ready")
+}
 ```
 
 `tmuxtest.NewServer(ctx, t)` captures the environment and working directory,
 resolves the tmux executable, and creates a server on its own socket.
-Construction can return an error. Test cleanup kills the server, and wait
-failures include the last captured screen. Source: `README.md`, "Testing your
-own code," backed by `tmux/tmuxtest/`.
+Setup failures stop the test. Test cleanup kills the server,
+and wait failures include the last captured screen. Call `tmuxtest.Main` once
+from `TestMain` before using these helpers. Run the test with `go test`; tmux
+3.2a or newer must be available on `PATH`.
+<!-- /port -->
 
+<!-- port:rs -->
 ```rust
 let guard = TestServer::new().await?;
 let server = guard.server();
@@ -57,7 +80,9 @@ these guards in doctests through `#![doc = include_str!("../README.md")]`.
 `libtmux::test::retry_until(deadline, condition)` polls an arbitrary async
 condition; `Pane::wait_for_text` waits specifically for pane text. See
 [Capturing output](../capturing-output/).
+<!-- /port -->
 
+<!-- port:java -->
 ```java
 @ExtendWith(TmuxExtension.class)
 class MyToolTest {
@@ -81,7 +106,9 @@ exited. Source: `libtmux-junit5/README.md`.
 from READMEs and guides, then runs them against `libtmux-junit5` servers. A
 `<!-- snippet: ... -->` directive can instead require a named exception, a
 compile failure, or an explicit skip reason. Source: `docs-tests/README.md`.
+<!-- /port -->
 
+<!-- port:dotnet -->
 ```csharp
 using LibTmux.Testing;
 
@@ -96,7 +123,9 @@ await scope.Pane.SendTextAsync("echo hello");
 when the block exits. Use `TmuxWait.UntilAsync` to wait for expected state; see
 [Capturing output](../capturing-output/). Source: `README.md`, "Testing your own
 code," exercised by `ReadmeExampleTests`.
+<!-- /port -->
 
+<!-- port:cxx -->
 ```cpp
 // A private tmux for a suite of your own, gone when the scope ends.
 auto fixture = libtmux::test::ScopedTmuxServer::start(
@@ -118,7 +147,9 @@ temporary directory, sets `TMUX_TMPDIR`, and removes `TMUX` and `TMUX_PANE` from
 the child environment. `SocketNamespace::consumer(...)` labels sockets with the
 consumer suite's name. `examples/tests/README.md` shows use from outside the
 library's build tree.
+<!-- /port -->
 
+<!-- port:swift -->
 ```swift
 import Testing
 import TmuxFixture
@@ -133,10 +164,13 @@ try await withTmuxServer { server in
 session and limits concurrent fixtures to reduce process and pseudo-terminal
 exhaustion. `LIBTMUX_TMUX_BIN` selects the executable; otherwise it checks
 installed locations. Source: `Tests/TmuxFixture/README.md`.
+<!-- /port -->
 
+<!-- port:ts -->
 TypeScript's harness at `packages/libtmux/src/_internal/test/testkit.ts` is
 internal and unpublished. For external tests, create an isolated `Server` and
 manage its cleanup in your test framework.
+<!-- /port -->
 
 ## Where to go next
 
diff --git a/site/src/content/docs/ports/cxx/examples/capture-pane-output.md b/site/src/content/docs/ports/cxx/examples/capture-pane-output.md
new file mode 100644
index 00000000..7d74d631
--- /dev/null
+++ b/site/src/content/docs/ports/cxx/examples/capture-pane-output.md
@@ -0,0 +1,142 @@
+---
+port: cxx
+route: examples/capture-pane-output
+title: Capture pane output
+description: Run a complete program that captures a pane and waits for a complete output line.
+sidebar:
+  label: Capture pane output
+  group: Examples
+  order: 3
+tableOfContents: true
+---
+
+A pane runs asynchronously: sending a command does not mean its output is
+already on screen. Capture repeatedly until the expected line appears, with a
+deadline so a failed command cannot leave the program waiting forever.
+
+This complete program creates a private tmux server, captures its output, and
+cleans up. Follow the [setup and run instructions](#setup-and-run) below. You need
+tmux and a Unix environment; no existing tmux session is required.
+
+## Read what's on screen
+
+The program sends `printf` with a leading newline, then waits for the complete
+line `libtmux capture ready`. The newline keeps a late shell prompt off that
+line. Matching the whole line avoids mistaking the echoed command for its output.
+
+```cpp title="capture.cpp"
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <thread>
+
+#include <libtmux/libtmux.hpp>
+#include <libtmux/testing/scoped_server.hpp>
+
+int main() {
+  auto cleanup = std::make_shared<libtmux::test::TeardownReport>();
+  bool captured = false;
+  try {
+    // This public fixture owns a private socket, uses /dev/null as its
+    // tmux configuration, and stops its server when the scope ends.
+    auto owned = libtmux::test::ScopedTmuxServer::start({
+        .session_name = "capture",
+        .socket_namespace = libtmux::test::SocketNamespace::consumer("capture"),
+        .teardown_report = cleanup,
+    });
+    if (!owned) throw std::runtime_error(owned.error());
+    auto server = libtmux::Server::at_socket_path(owned->socket_path());
+    if (!server) throw std::runtime_error(server.error().diagnostic);
+    auto panes = server->panes();
+    if (!panes) throw std::runtime_error(panes.error().diagnostic);
+    if (panes->empty()) throw std::runtime_error("The session has no pane");
+    const auto& pane = panes->front();
+
+    auto sent = pane.send_line("printf '\\nlibtmux capture ready\\n'");
+    if (!sent) throw std::runtime_error(sent.error().diagnostic);
+    const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds{5};
+    while (std::chrono::steady_clock::now() < deadline && !captured) {
+      auto text = pane.capture();
+      if (!text) throw std::runtime_error(text.error().diagnostic);
+      std::istringstream lines{*text};
+      for (std::string line; std::getline(lines, line);) {
+        if (line == "libtmux capture ready") {
+          std::cout << line << '\n';
+          captured = true;
+          break;
+        }
+      }
+      if (!captured) std::this_thread::sleep_for(std::chrono::milliseconds{25});
+    }
+    if (!captured) {
+      throw std::runtime_error("Output did not arrive within five seconds");
+    }
+  } catch (const std::exception& error) {
+    std::cerr << error.what() << '\n';
+    captured = false;
+  }
+  for (const auto& message : cleanup->messages) {
+    if (message != "server teardown complete") {
+      std::cerr << message << '\n';
+      captured = false;
+    }
+  }
+  return captured ? 0 : 1;
+}
+```
+
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
+
+## Wait for output or completion
+
+The program above checks the captured screen for up to five seconds. The short
+pause between checks limits polling; the observed output determines when the loop
+finishes. A tmux capture is a view of the screen and scrollback, so it can miss
+output that has already scrolled away. Use a stream or a completion signal for
+long-running commands when that distinction matters.
+
+[Capturing output](/guides/capturing-output/) covers capture options, while
+[Sending keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site)
+explains why sending and waiting are separate operations.
+
+## Setup and run
+
+Use an empty directory. The commands pin the library
+revision used to verify the program.
+
+Save the program and build file using the displayed names. Use CMake
+3.25 or newer, Ninja, and Clang 18 with libc++ 18 on Linux. The public testing
+library supplies the private server's lifetime management; it is linked explicitly below.
+
+```cmake title="CMakeLists.txt"
+cmake_minimum_required(VERSION 3.25)
+project(capture_example LANGUAGES CXX)
+set(LIBTMUX_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(LIBTMUX_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(LIBTMUX_BUILD_TESTING_LIBRARY ON CACHE BOOL "" FORCE)
+add_subdirectory(libtmux-source)
+add_executable(capture capture.cpp)
+target_compile_features(capture PRIVATE cxx_std_23)
+target_link_libraries(capture PRIVATE libtmux::libtmux libtmux::testing)
+```
+
+```console
+$ git clone https://github.com/libtmux/libtmux-cxx libtmux-source &&
+  git -C libtmux-source checkout 393d4b0ad666f18a6581f1eb281741a75a7503f0 &&
+  cmake -S . -B build -G Ninja \
+    -DCMAKE_CXX_COMPILER=clang++ \
+    -DCMAKE_CXX_FLAGS=-stdlib=libc++ \
+    -DCMAKE_EXE_LINKER_FLAGS=-stdlib=libc++ &&
+  cmake --build build --target capture --parallel 2 &&
+  ./build/capture
+```
+
+<a id="source-inclusion"></a>
+
+## Where this comes from
+
+This complete program was run against the library revision pinned above.
+The displayed code is checked against the bytes from that run.
diff --git a/site/src/content/docs/ports/cxx/workspace/internals/examples.md b/site/src/content/docs/ports/cxx/workspace/internals/examples.md
index 0c42bfcc..1045ce21 100644
--- a/site/src/content/docs/ports/cxx/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/cxx/workspace/internals/examples.md
@@ -10,40 +10,109 @@ sidebar:
 tableOfContents: true
 ---
 
-The consumer's builder test creates an editor window with two panes and a logs
-window with one pane. It uses `ScopedTmuxServer` to isolate and clean up tmux.
+Build an editor window with two panes and a logs window with one pane on a
+private tmux server. This walkthrough uses a POSIX host with tmux, CMake 3.25
+or newer, Clang 18, and the libc++ 18 development libraries.
 
-## Describe two windows
+## Create the project
 
-With `libtmux_consumers/workspace.hpp` included and a core `Server` named
-`server`, this is the description used by the real-tmux test:
+In a new directory, fetch the source revision used by this documentation:
 
-```cpp
-namespace workspace = libtmux::workspace;
+```console
+$ mkdir cxx-workspace-example
+$ cd cxx-workspace-example
+$ git init -q libtmux-source
+$ git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-cxx.git
+$ git -C libtmux-source fetch --depth=1 origin 393d4b0ad666f18a6581f1eb281741a75a7503f0
+$ git -C libtmux-source checkout --detach FETCH_HEAD
+```
+
+Save the following build file. The typed builder is a source header; this example
+does not use the optional YAML reader. The public testing library supplies
+private-server startup and cleanup.
+
+```cmake title="CMakeLists.txt"
+cmake_minimum_required(VERSION 3.25)
+project(workspace_example LANGUAGES CXX)
+
+set(LIBTMUX_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(LIBTMUX_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(LIBTMUX_BUILD_TESTING_LIBRARY ON CACHE BOOL "" FORCE)
+add_subdirectory(libtmux-source)
+
+add_executable(workspace-example main.cpp)
+target_compile_features(workspace-example PRIVATE cxx_std_23)
+target_include_directories(workspace-example PRIVATE
+    libtmux-source/examples/workspace/include)
+target_link_libraries(workspace-example PRIVATE
+    libtmux::libtmux libtmux::testing)
+```
 
-const workspace::Workspace description{
-    .session_name = "built",
-    .windows = {{.name = "editor", .panes = {{}, {}}},
-                {.name = "logs", .panes = {{}}}}};
-const auto built = workspace::build(server, description);
-if (!built.has_value()) {
-    throw std::runtime_error(built.error().reason);
+## Build and inspect
+
+Save this complete program as `main.cpp`:
+
+```cpp title="main.cpp"
+#include <iostream>
+#include <memory>
+#include <stdexcept>
+
+#include "libtmux/server.hpp"
+#include "libtmux/testing/scoped_server.hpp"
+#include "libtmux_consumers/workspace.hpp"
+
+int main() {
+    auto cleanup = std::make_shared<libtmux::test::TeardownReport>();
+    bool complete = false;
+    try {
+        auto owned = libtmux::test::ScopedTmuxServer::start({.teardown_report = cleanup});
+        if (!owned) throw std::runtime_error(owned.error());
+        auto server = libtmux::Server::at_socket_path(owned->socket_path().string());
+        if (!server) throw std::runtime_error(server.error().diagnostic);
+
+        namespace workspace = libtmux::workspace;
+        const workspace::Workspace description{
+            .session_name = "built",
+            .windows = {{.name = "editor", .panes = {{.shell = "/bin/cat"}, {.shell = "/bin/cat"}}},
+                        {.name = "logs", .panes = {{.shell = "/bin/cat"}}}}};
+        const auto built = workspace::build(*server, description);
+        if (!built) throw std::runtime_error(built.error().reason);
+        const auto windows = built->windows();
+        if (!windows) throw std::runtime_error(windows.error().diagnostic);
+        const auto panes = windows->front().panes();
+        if (!panes) throw std::runtime_error(panes.error().diagnostic);
+        std::cout << built->name() << ": " << windows->size() << " windows\n";
+        std::cout << "editor: " << panes->size() << " panes\n";
+        complete = true;
+    } catch (const std::exception& error) {
+        std::cerr << error.what() << '\n';
+    }
+    for (const auto& message : cleanup->messages) {
+        if (message != "server teardown complete") {
+            std::cerr << message << '\n';
+            complete = false;
+        }
+    }
+    return complete ? 0 : 1;
 }
 ```
 
-The error-handling line needs `<stdexcept>`. The consumer headers and
-`workspace_builder` target come from the source checkout. For a complete
-isolated setup, run the linked test rather than targeting your normal server.
+Configure, build and run from the example directory:
 
-## YAML and command checks
+```console
+$ cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_CXX_COMPILER=clang++-18 -DCMAKE_CXX_FLAGS=-stdlib=libc++
+$ cmake --build build --parallel 2 --target workspace-example
+$ ./build/workspace-example
+```
 
-`tmuxp_test.cpp` reads command shorthand and mappings, reports unsupported
-fields, and verifies the resulting values. `workspace_test.cpp` checks live
-windows and panes, command delivery under non-default pane indexes,
-environment values, and text sent without Enter.
+The program prints `built: 2 windows` and `editor: 2 panes`. The owned fixture
+creates a private socket and removes its server and temporary files when the
+scope ends, including during exception handling. Each pane runs `/bin/cat`,
+which waits for input without loading an interactive shell configuration.
 
-Run both groups with the [consumer guide](../guides/). These tests exercise
-the consumer's public use of libtmux; they do not make its workspace types part
-of the installed core package.
+This header belongs to the source consumer. Installing the core package alone
+does not supply the workspace include directory. For YAML input, the separate
+consumer build also needs its parser and yaml-cpp dependency.
 
-[Builder test](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/tests/workspace_test.cpp); [YAML tests](https://github.com/libtmux/libtmux-cxx/blob/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee/examples/workspace/tests/tmuxp_test.cpp).
+[Workspace builder source](https://github.com/libtmux/libtmux-cxx/blob/393d4b0ad666f18a6581f1eb281741a75a7503f0/examples/workspace/include/libtmux_consumers/workspace.hpp)
diff --git a/site/src/content/docs/ports/cxx/workspace/internals/index.md b/site/src/content/docs/ports/cxx/workspace/internals/index.md
index d1821c94..1cb0d9e3 100644
--- a/site/src/content/docs/ports/cxx/workspace/internals/index.md
+++ b/site/src/content/docs/ports/cxx/workspace/internals/index.md
@@ -10,9 +10,9 @@ sidebar:
 tableOfContents: true
 ---
 
-These pages document the in-development workspace builder for contributors
-and applications that call its APIs. For workspace loading from a terminal,
-see [tmuxp](https://tmuxp.git-pull.com/).
+Build and inspect tmux sessions from application code with the workspace
+library. To load files from a terminal, start with the
+[native CLI walkthrough](../guides/installation/).
 
 ## Builder pipeline
 
@@ -31,7 +31,7 @@ builder tests; they do not load workspace files as a user application.
 ## Implementation scope
 
 The C++ repository includes a workspace consumer that builds a described tmux
-session and reads [tmuxp](https://tmuxp.git-pull.com)-style YAML. It exercises
+session and reads YAML. It exercises
 libtmux's public API from a separate target.
 
 The workspace headers and parser belong to `examples/workspace`. They are
diff --git a/site/src/content/docs/ports/cxx/workspace/internals/topics.md b/site/src/content/docs/ports/cxx/workspace/internals/topics.md
index 5d695651..01237a4c 100644
--- a/site/src/content/docs/ports/cxx/workspace/internals/topics.md
+++ b/site/src/content/docs/ports/cxx/workspace/internals/topics.md
@@ -19,7 +19,7 @@ core `Server`.
 Configuration covers session and window names, working directories,
 environment values, options, layouts, focus, window indexes, and pane
 commands. The YAML reader rejects keys outside its supported subset and
-returns a document path and reason. Python runtime features are not loaded.
+returns a document path and reason.
 
 A `Command` holds text, whether to press Enter, pauses before and after
 sending, and history suppression. A command with `enter: false` leaves text
diff --git a/site/src/content/docs/ports/cxx/workspace/reference/compatibility.md b/site/src/content/docs/ports/cxx/workspace/reference/compatibility.md
index 2d5261a7..30c312bb 100644
--- a/site/src/content/docs/ports/cxx/workspace/reference/compatibility.md
+++ b/site/src/content/docs/ports/cxx/workspace/reference/compatibility.md
@@ -1,178 +1,49 @@
 ---
-title: "tmuxp compatibility and port status"
-description: "Current local CLI capabilities, remaining gaps, and the historical builder audit."
+title: Runtime and configuration support
+description: Runtime requirements and configuration boundaries for the C++ workspace command.
 port: cxx
 product: workspace
 sidebar:
-  label: "tmuxp compatibility and port status"
+  label: Runtime and configuration support
   group: "Reference"
   order: 30
 tableOfContents: true
 ---
 
-**Local implementation, unpublished.** The C++ `tmux-workspace` CLI
-is available in the `workspace-cli` source worktree. Its command and
-configuration coverage remains partial. See [installation](../../guides/installation/)
-for local setup; installing a published library does not establish availability
-of this CLI.
+`tmux-workspace` is the C++ command for loading and capturing tmux
+workspaces. The [installation guide](../../guides/installation/) builds the
+documented source revision and runs a session on a private socket. The
+walkthroughs require tmux 3.2a or newer.
 
-Compatibility targets useful tmuxp 1.74.0 commands and workspace workflows, with
-native validation, execution and output conventions. Matching command names does
-not promise identical runtime behavior or Python semantics.
+## Runtime and execution
 
-## This port
+Build with the repository's `cxx-dev` CMake preset and its selected compiler.
+Native services handle loading, capture, discovery, search, conversion, import
+and editing. Search uses C++ ECMAScript regular expressions.
 
-The optional application provides native `ls`, `search`, `edit`, `convert`,
-`import teamocil`, `import tmuxinator`, `debug-info`, `load` and `freeze`.
-The optional [shell](../../cli/shell/#native-execution) invokes an installed
-tmuxp 1.74.0 executable through native process and terminal handling. Select
-the executable with `PATH` or `TMUX_WORKSPACE_TMUXP`; native loading does not
-require Python. Machine shells require `-c` and retain structured output.
+Plugins and custom workspace builders are unsupported. `shell` is a separate
+optional feature that runs tmuxp 1.74.0; select its interpreter with
+`TMUX_WORKSPACE_PYTHON`, or select the executable with `TMUX_WORKSPACE_TMUXP`.
 
-Loading starts tmux when needed, creates sessions or reuses exact names. It
-retains created object identities and supports command settings, directories,
-environment, shells, layouts, indexes and focus. A session-name override applies
-to the final input. Failed builds remove their own session and preserve earlier
-successful inputs. Cold startup verifies the daemon and bootstrap session;
-uncertain identity is reported as possibly retained state. Append authenticates
-the inherited daemon and current pane, preserves existing windows and reports
-new windows/settings retained after failure.
+Use detached loading when no unambiguous controlling terminal or tmux client
+is available. Append retains its borrowed session and reports changes that
+remain after a failure.
 
-Ordinary human load requires a foreground controlling terminal before mutation.
-Outside tmux it attaches; inside tmux it switches the unique non-control client
-viewing the invoking pane. Zero or multiple matching clients are refused with
-`-d` guidance. The final input selects the destination, including a reused
-session. Machine load requires `-d` or `--append`.
+The workspace library has its own configuration and construction APIs; use
+their reference for C++ application code.
 
-Independent `active-pane` focus on the invoking physical window requires `-d`
-or `--append`, including linked windows. This check runs before loading and
-handoff; clients on other physical windows do not block switching.
+## Configuration and failure handling
 
-Load flushes both output streams before handoff and retains loaded changes on
-handoff failure. It rechecks the selected client's identity before switching;
-tmux's name-targeted switch still leaves a race after that check. Attachment
-needs a standard stream identifying the concrete controlling tty. With all
-three standard streams redirected, use `-d`. See [load](../../cli/load/#native-c-loading).
+Read [configuration](../../configuration/) for the CLI's fields. Unsupported
+execution fields fail visibly; generic [conversion](../../cli/convert/)
+preserves document values without proving that they can be executed.
 
-`before_script` invokes quoted argv directly, after session creation or append
-selection and before workspace settings and windows. Reusing a session skips
-the script. All inputs' script arguments, directories and environment names
-are validated before creation. The working directory is the configured session
-directory, or the invoking directory when omitted.
+Use [machine output](../output/) for automation and check both the process
+status and any retained effects. Capture reads live tmux state; it cannot
+recover original command arguments, scripts, comments or application state.
 
-Script stdin is closed. Each output stream retains up to 1 MiB; NDJSON also
-emits script-output records while the child runs. Script failure or an output
-limit removes only a newly owned session. Append preserves its borrowed session
-and reports partial effects. Interruption joins the child group, and remaining
-group processes are terminated when the script exits. No fixed script deadline
-is imposed.
+[Examples](../../examples/gallery/) provide complete starter documents. Their
+pane commands can need additional applications and directories when adapted.
+Use [library internals](../../internals/) for the programmatic builder.
 
-Conversion preserves extension fields. Imports validate source shapes and
-translate supported command grouping, roots, layouts, focus and options.
-Unsupported lifecycle, title and synchronization behavior is refused before
-saving. See [native imports](../../cli/import/#native-c-imports).
-Capture records current commands, directories, window names, indexes, focus,
-layouts and local session/window options. Indexed options and escaped values
-survive reload; `synchronize-panes` is restored after pane creation. Inherited
-and global options and environment are omitted. Capture warns about
-unrecoverable original arguments, history and scripts. Search uses native C++
-ECMAScript regular expressions.
-
-Layout syntax is checked across all inputs before scripts or session creation.
-Named-layout and JSON-format availability follow the running daemon's version,
-or the selected client when starting a new server. Saved layouts accept legacy
-checksum strings and JSON v2 from tmux next-3.9, including floating-pane metadata.
-Custom layout checks validate syntax and pane capacity; tmux owns geometry and
-pruning to the requested pane count.
-
-Every command accepts `--json` and `--ndjson`; NDJSON takes precedence. Load
-flushes events and a terminal result. Diagnostics use stderr and control bytes
-remain escaped in machine strings. Explicit saves publish an owned temporary
-file and require `--force` for replacement. `load -2` selects 256-color mode;
-`-8` fails before document lookup or tmux access.
-
-Human load progress uses terminal stderr, five presets or a custom template.
-Counters track delivered pane commands and configured delays, not program exits.
-`--progress-lines` bounds the script panel; failure retains its final bounded
-tail. Redirected stdout receives script output once. Without the panel, both
-script streams flush to their original destinations as data arrives.
-
-Machine output, redirected stderr, `TERM=dumb` and explicit progress disabling
-suppress the panel. Resize clears it and restores ordinary stream delivery.
-Progress preserves cursor visibility and terminal modes. Interruptions cancel
-configured delays and check between topology, command, option and focus steps.
-
-`load --log-file PATH` appends JSON diagnostics. `--log-level` defaults to
-`warning`; `info` includes load lifecycle records and `debug` adds script-output
-chunks. Required errors and machine results remain visible at every level.
-Invalid file destinations fail before mutation; later file errors preserve
-command status, cleanup and handoff. See [logging](../output/#native-c-logging).
-
-Native Bash, Zsh and Fish completion covers nested commands, flags, enumerated
-values and file paths. Dynamic session/configuration-name discovery remains
-unavailable. See [completion](../../cli/completion/#native-completion).
-
-The editor receives parsed argv directly, using `VISUAL`, then `EDITOR`, then
-`vi`. It can take the controlling terminal while machine stdout stays separate.
-Without a terminal, output is bounded; exceeding the limit terminates the owned
-child group. SIGINT/SIGTERM cancel captured children and their pipe-owning
-descendants. Suspend/resume and non-Linux behavior need further validation.
-
-The local source reference is apps/workspace/README.md. Use the native
-executable's `--help` for the options implemented in that checkout.
-
-### Remaining gaps
-
-- Python plugins and custom builders are unavailable.
-- Windows created by arbitrary scripts are outside the builder's retained-window
-  records, including when a borrowed append session survives script failure.
-- Dynamic session/configuration-name completion remains unavailable.
-- Additional importer fields, full configuration/capture coverage and
-  supported-platform packaging remain open. Append's first explicit window
-  index must name a free slot in the existing session.
-
-## Historical builder audit
-
-Audit date: 2026-09-09. [Native source snapshot](https://github.com/libtmux/libtmux-cxx/tree/c7f1146d2ebd7a8323d9f9814517dc3cdf86b4ee).
-The following results describe that original library revision, before the local
-CLI implementation. They are historical evidence, not its current capability
-list or a support guarantee for a published artifact.
-
-The library parsed 21 upstream YAML examples in the original audit. Live probes
-found gaps in index assignment and command routing, first-pane environment,
-split shell inheritance and `options_after` timing. The source snapshot had no
-native CLI.
-
-At that baseline, the workspace consumer was a source-tree library target. Its
-YAML parser rejected fields outside its supported subset, and builder failures
-could leave earlier tmux changes in place. These historical library results do
-not describe the current CLI's owned-session cleanup and append reporting.
-
-Read the port's [builder topics](../../internals/topics/) and
-[API](../) for its library interface. Use the language switcher
-to compare the same topic across ports; each port has its own coverage limits.
-
-## Shared gaps
-
-Parser acceptance does not prove execution support. Native regex engines and
-Python plugin runtimes have different contracts; identical flags alone do not
-establish compatibility. See [shell](../../cli/shell/),
-[search](../../cli/search/) and [hooks](../../configuration/hooks/), and apply
-this port's current limitations above when reading those reference pages.
-
-## Optional format separator
-
-Python libtmux exposes `LIBTMUX_TMUX_FORMAT_SEPARATOR` in its format collector.
-This native CLI does not claim that setting as a supported codec control. Its
-framing and decoding need their own compatible seam and collision, empty value,
-Unicode and line-break checks before accepting such a setting.
-
-## Reading examples
-
-The [gallery](../../examples/gallery/) contains the upstream fixture corpus.
-Parsing a fixture and executing its applications are separate checks. Several
-require external programs, remote hosts, project directories or plugin
-packages. A successful YAML read does not establish those dependencies or the
-complete workspace behavior.
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+[CLI source](https://github.com/libtmux/libtmux-cxx/blob/9c8c6a264114277df84c9f6819855093adae5c6e/apps/workspace/README.md).
diff --git a/site/src/content/docs/ports/dotnet/examples/capture-pane-output.md b/site/src/content/docs/ports/dotnet/examples/capture-pane-output.md
new file mode 100644
index 00000000..37d5dcb8
--- /dev/null
+++ b/site/src/content/docs/ports/dotnet/examples/capture-pane-output.md
@@ -0,0 +1,139 @@
+---
+port: dotnet
+route: examples/capture-pane-output
+title: Capture pane output
+description: Run a complete program that captures a pane and waits for a complete output line.
+sidebar:
+  label: Capture pane output
+  group: Examples
+  order: 3
+tableOfContents: true
+---
+
+A pane runs asynchronously: sending a command does not mean its output is
+already on screen. Capture repeatedly until the expected line appears, with a
+deadline so a failed command cannot leave the program waiting forever.
+
+This complete program creates a private tmux server, captures its output, and
+cleans up. Follow the [setup and run instructions](#setup-and-run) below. You need
+tmux and a Unix environment; no existing tmux session is required.
+
+## Read what's on screen
+
+The program sends `printf` with a leading newline, then waits for the complete
+line `libtmux capture ready`. The newline keeps a late shell prompt off that
+line. Matching the whole line avoids mistaking the echoed command for its output.
+
+```csharp title="Program.cs"
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using LibTmux;
+
+if (OperatingSystem.IsWindows())
+    throw new PlatformNotSupportedException("Run this example on Linux or macOS");
+
+string directory = Path.Combine(
+    "/tmp/libtmux-dotnet-dev", Guid.NewGuid().ToString("N"));
+Directory.CreateDirectory(directory);
+try
+{
+    using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+    CancellationToken token = timeout.Token;
+    await using OwnedServerScope owned = await Server.CreateOwnedAsync(
+        new ServerConnectionOptions
+        {
+            SocketPath = Path.Combine(directory, "tmux.sock"),
+            ConfigurationFile = "/dev/null",
+            ChildEnvironment = new Dictionary<string, string?>
+            {
+                ["TMUX"] = null,
+                ["TMUX_PANE"] = null,
+                ["ENV"] = null,
+                ["BASH_ENV"] = null,
+            },
+        }, token);
+    Session session = await owned.Value.CreateSessionAsync(
+        new NewSessionRequest { Name = "capture", Command = "/bin/sh" }, token);
+    Pane pane = (await session.GetPanesAsync(token))[0];
+    await pane.SendTextAsync(
+        "printf '\\nlibtmux capture ready\\n'", cancellationToken: token);
+
+    var elapsed = Stopwatch.StartNew();
+    bool captured = false;
+    while (elapsed.Elapsed < TimeSpan.FromSeconds(5))
+    {
+        var lines = await pane.CaptureAsync(cancellationToken: token);
+        if (lines.Contains("libtmux capture ready"))
+        {
+            Console.WriteLine("libtmux capture ready");
+            captured = true;
+            break;
+        }
+        await Task.Delay(25, token);
+    }
+    if (!captured)
+        throw new TimeoutException("Output did not arrive within five seconds");
+}
+finally
+{
+    Directory.Delete(directory, recursive: true);
+}
+```
+
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
+
+## Wait for output or completion
+
+The program above checks the captured screen for up to five seconds. The short
+pause between checks limits polling; the observed output determines when the loop
+finishes. A tmux capture is a view of the screen and scrollback, so it can miss
+output that has already scrolled away. Use a stream or a completion signal for
+long-running commands when that distinction matters.
+
+[Capturing output](/guides/capturing-output/) covers capture options, while
+[Sending keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site)
+explains why sending and waiting are separate operations.
+
+## Setup and run
+
+Use an empty directory. The commands pin the library
+revision used to verify the program.
+
+Save the program and project file using the displayed names. Use the .NET 10
+SDK. The project disables implicit imports, so every required import
+appears in the program.
+
+```xml title="Capture.csproj"
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <ProjectReference Include="libtmux-source/src/LibTmux/LibTmux.csproj" />
+  </ItemGroup>
+</Project>
+```
+
+```console
+$ git clone https://github.com/libtmux/libtmux-dotnet libtmux-source &&
+  git -C libtmux-source checkout 320dc64f4b8b7815842471327a5e6b84a1499bf8 &&
+  dotnet build Capture.csproj --maxcpucount:1 &&
+  dotnet run --project Capture.csproj --no-build
+```
+
+<a id="source-inclusion"></a>
+
+## Where this comes from
+
+This complete program was run against the library revision pinned above.
+The displayed code is checked against the bytes from that run.
diff --git a/site/src/content/docs/ports/dotnet/workspace/internals/examples.md b/site/src/content/docs/ports/dotnet/workspace/internals/examples.md
index 96575505..09be21b8 100644
--- a/site/src/content/docs/ports/dotnet/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/dotnet/workspace/internals/examples.md
@@ -10,51 +10,104 @@ sidebar:
 tableOfContents: true
 ---
 
-The workspace package README demonstrates parsing a two-window description
-and inspecting its typed result. Its documentation examples are compiled and
-run by the port's README example tests.
-
-## Parse and build
-
-Within an async method that already has a LibTmux `Server` and cancellation
-token `ct`, import `LibTmux.Workspace` and use:
-
-```csharp
-WorkspaceFile workspace = WorkspaceFile.Parse("""
-    session_name: api
-    start_directory: /tmp
-    windows:
-      - window_name: editor
-        panes:
-          - shell_command: echo editing
-      - window_name: server
-        panes:
-          - shell_command: echo serving
-    """);
-
-WorkspaceResult result = await new WorkspaceBuilder(server)
-    .BuildAsync(workspace, ct);
-Console.WriteLine($"{result.Session.Name}: {result.Windows.Count} windows");
+Build a two-window workspace, print its size, and remove its private tmux server.
+Use a POSIX host with tmux on `PATH` and the .NET 10 SDK.
+
+## Create the project
+
+In a new directory, fetch the source revision used by this documentation:
+
+```console
+$ mkdir dotnet-workspace-example
+$ cd dotnet-workspace-example
+$ git init -q libtmux-source
+$ git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-dotnet.git
+$ git -C libtmux-source fetch --depth=1 origin 320dc64f4b8b7815842471327a5e6b84a1499bf8
+$ git -C libtmux-source checkout --detach FETCH_HEAD
+```
+
+Save the following project file. The project reference builds the workspace
+package and its core dependency from that checkout.
+
+```xml title="WorkspaceExample.csproj"
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <ProjectReference Include="libtmux-source/src/LibTmux/LibTmux.csproj" />
+    <ProjectReference Include="libtmux-source/src/LibTmux.Workspace/LibTmux.Workspace.csproj" />
+  </ItemGroup>
+</Project>
 ```
 
-The workspace starts in the configured directory and returns two windows.
-The [guide](../guides/) supplies the missing application setup and a server
-scope that performs cleanup. Use the result's `Unsupported` entries to report
-layouts rejected by tmux.
+## Build and inspect
 
-## Verification
+Save this complete program as `Program.cs` beside the project file:
 
-The port's integration project contains workspace parsing, builder, readiness,
-and partial-result checks. From a prepared source checkout, run them with:
+```csharp title="Program.cs"
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using LibTmux;
+using LibTmux.Workspace;
+
+internal static class Program
+{
+    private static async Task Main()
+    {
+        if (OperatingSystem.IsWindows())
+            throw new PlatformNotSupportedException("This example requires POSIX tmux.");
+
+        using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        WorkspaceFile workspace = WorkspaceFile.Parse("""
+            session_name: built
+            options:
+              default-shell: /bin/sh
+            windows:
+              - window_name: editor
+                panes:
+                  - shell_command: echo editing
+                  - shell_command: echo watching
+              - window_name: server
+                panes:
+                  - shell_command: echo serving
+            """);
+
+        await using var owned = await Server.CreateOwnedAsync(
+            new ServerConnectionOptions
+            {
+                SocketName = $"workspace-{Guid.NewGuid():N}",
+                ConfigurationFile = "/dev/null",
+            },
+            deadline.Token);
+        WorkspaceResult result = await new WorkspaceBuilder(owned.Value)
+            .BuildAsync(workspace, deadline.Token);
+        Console.WriteLine($"{result.Session.Name}: {result.Windows.Count} windows");
+        foreach (string unsupported in result.Unsupported)
+            Console.WriteLine(unsupported);
+    }
+}
+```
+
+Build and run it from the example directory:
 
 ```console
-$ dotnet test tests/LibTmux.IntegrationTests \
-    --framework net10.0 \
-    --filter FullyQualifiedName~Workspace
+$ dotnet run --project WorkspaceExample.csproj --configuration Release
 ```
 
-A separate package-consumer program parses workspace data through the packed
-package to check that the optional dependency is usable outside the source
-project. Rendering this page is not an execution of either test path.
+The program prints `built: 2 windows`. The owned scope removes the server on
+success or failure. Its unique socket and empty tmux configuration keep the
+example separate from an existing server. The deadline bounds construction;
+owned-scope cleanup uses its own lifetime.
+
+`BuildAsync` returns after creating the workspace and sending its commands.
+That does not establish completion of programs running in the panes. A build
+failure can leave partial results; the owned server scope removes them here.
 
-[README example](https://github.com/libtmux/libtmux-dotnet/blob/6656a563ec9e07ab52e0c3ac96f7704fc94cc0c0/src/LibTmux.Workspace/README.md); [Package consumer](https://github.com/libtmux/libtmux-dotnet/blob/6656a563ec9e07ab52e0c3ac96f7704fc94cc0c0/tests/LibTmux.PackageConsumer/Program.cs).
+[Workspace API source](https://github.com/libtmux/libtmux-dotnet/tree/320dc64f4b8b7815842471327a5e6b84a1499bf8/src/LibTmux.Workspace)
diff --git a/site/src/content/docs/ports/dotnet/workspace/internals/guides.md b/site/src/content/docs/ports/dotnet/workspace/internals/guides.md
index 87d2bf62..9d10e687 100644
--- a/site/src/content/docs/ports/dotnet/workspace/internals/guides.md
+++ b/site/src/content/docs/ports/dotnet/workspace/internals/guides.md
@@ -1,6 +1,6 @@
 ---
 title: "Use the .NET workspace builder"
-description: "Use the in-development .NET workspace builder from application code."
+description: "Parse a workspace, build it on an owned server, and handle partial failures."
 port: dotnet
 product: workspace
 sidebar:
@@ -10,66 +10,39 @@ sidebar:
 tableOfContents: true
 ---
 
-Install the workspace package in a .NET console project. With the .NET 10 SDK,
-add the current prerelease:
+Use `WorkspaceFile.Parse` to read workspace YAML and `WorkspaceBuilder.BuildAsync`
+to create its session, windows, and panes. Parsing needs no running tmux server;
+building requires tmux on a Unix host.
 
-```console
-$ dotnet package add LibTmux.Workspace --prerelease
-```
-
-Retain the resolved version in the project or central package file. Building
-requires tmux on the host; parsing YAML does not.
+Start with the [complete workspace example](../examples/). It includes the
+program, project file, dependency checkout, and run command for the .NET 10 SDK.
+The example creates a private server and removes it when the owned scope ends.
 
 ## Create an isolated workspace
 
-Replace the console application's program with this example. The owned server
-scope selects a fresh socket and removes that server when disposed, including
-if building throws.
-
-```csharp
-using LibTmux;
-using LibTmux.Workspace;
-
-if (OperatingSystem.IsWindows())
-    throw new PlatformNotSupportedException("This example requires tmux on Unix.");
-
-WorkspaceFile workspace = WorkspaceFile.Parse("""
-    session_name: guide
-    windows:
-      - window_name: editor
-        panes:
-          - shell_command: echo ready
-      - window_name: server
-        panes:
-          - shell_command: echo serving
-    """);
+Parse the YAML before opening the server. Create an owned scope with
+`Server.CreateOwnedAsync`, passing a `ServerConnectionOptions` object with
+the fresh socket name and configuration file. Pass the scope's server to
+`WorkspaceBuilder`, then await `BuildAsync` with a cancellation token. Use
+`await using` so the scope is disposed even when building throws.
 
-await using var owned = await Server.CreateOwnedAsync(
-    new ServerConnectionOptions(socketName: $"workspace-{Guid.NewGuid():N}"));
-WorkspaceResult result = await new WorkspaceBuilder(owned.Value)
-    .BuildAsync(workspace);
-Console.WriteLine($"{result.Session.Name}: {result.Windows.Count} windows");
-foreach (string unsupported in result.Unsupported)
-    Console.WriteLine(unsupported);
-```
-
-Run the console project:
-
-```console
-$ dotnet run
-```
+The returned `WorkspaceResult` identifies the session and its windows.
+Inspect `Unsupported` for layouts that tmux rejected after creating their
+windows. Keep the owned scope alive while your application uses the workspace;
+disposing it removes its server and the sessions on that server.
 
 ## Read a file and handle errors
 
-Pass `File.ReadAllText("session.yaml")` to `WorkspaceFile.Parse` to load a
-file. Resolve relative working directories yourself if they should be based
-on the file's location.
+Read the YAML file as text and pass it to `WorkspaceFile.Parse`.
+Resolve relative working directories yourself if they
+should be based on that file's location.
 
 For an existing application server, pass its handle to `WorkspaceBuilder`
-instead of creating an owned scope. Keep the returned session running for as
-long as your application needs it. Inspect
-`WorkspaceBuildException.PartialResult`
-after a failure and decide what to remove; the builder has no automatic
-rollback.
-
-[Builder API](https://github.com/libtmux/libtmux-dotnet/blob/6656a563ec9e07ab52e0c3ac96f7704fc94cc0c0/src/LibTmux.Workspace/WorkspaceBuilder.cs); [Owned server lifetime](https://github.com/libtmux/libtmux-dotnet/blob/6656a563ec9e07ab52e0c3ac96f7704fc94cc0c0/src/LibTmux/Server.Lifecycle.cs).
+instead of creating an owned scope. A failed build can leave a partial session.
+Inspect `WorkspaceBuildException.PartialResult` and decide what to remove;
+the builder does not roll back changes automatically.
+
+The [builder source](https://github.com/libtmux/libtmux-dotnet/blob/320dc64f4b8b7815842471327a5e6b84a1499bf8/src/LibTmux.Workspace/WorkspaceBuilder.cs)
+describes the build result and partial-failure behavior. See
+[owned server lifetime](https://github.com/libtmux/libtmux-dotnet/blob/320dc64f4b8b7815842471327a5e6b84a1499bf8/src/LibTmux/Server.Lifecycle.cs)
+for scope cleanup.
diff --git a/site/src/content/docs/ports/dotnet/workspace/internals/index.md b/site/src/content/docs/ports/dotnet/workspace/internals/index.md
index f6e763c3..4d003fcd 100644
--- a/site/src/content/docs/ports/dotnet/workspace/internals/index.md
+++ b/site/src/content/docs/ports/dotnet/workspace/internals/index.md
@@ -10,9 +10,9 @@ sidebar:
 tableOfContents: true
 ---
 
-These pages document the in-development workspace builder for contributors
-and applications that call its APIs. For workspace loading from a terminal,
-see [tmuxp](https://tmuxp.git-pull.com/).
+Build and inspect tmux sessions from application code with the workspace
+library. To load files from a terminal, start with the
+[native CLI walkthrough](../guides/installation/).
 
 ## Builder pipeline
 
@@ -30,7 +30,7 @@ command-line handling, attachment, and server lifetime.
 
 ## Implementation scope
 
-`LibTmux.Workspace` reads a [tmuxp](https://tmuxp.git-pull.com)-style YAML file
+`LibTmux.Workspace` reads a YAML file
 and builds its session through LibTmux. It returns the session, materialized
 windows, and any layouts that tmux rejected while leaving their windows usable.
 
@@ -43,7 +43,8 @@ The package targets .NET 8 and .NET 10 and uses YamlDotNet. tmux must run on
 the host. Pin the prerelease selected by your package manager because public
 contracts can change between alpha versions.
 
-The accepted format is a closed subset. Unknown keys, Python plugins,
-configuration search paths, and tmuxp hooks are not silently accepted.
+The parser rejects unknown fields. The caller reads the file and selects
+the server; parsing does not search configuration directories or load
+extensions.
 
 [Package documentation](https://github.com/libtmux/libtmux-dotnet/blob/6656a563ec9e07ab52e0c3ac96f7704fc94cc0c0/src/LibTmux.Workspace/README.md)
diff --git a/site/src/content/docs/ports/dotnet/workspace/reference/compatibility.md b/site/src/content/docs/ports/dotnet/workspace/reference/compatibility.md
index 936d45a0..c77aeee6 100644
--- a/site/src/content/docs/ports/dotnet/workspace/reference/compatibility.md
+++ b/site/src/content/docs/ports/dotnet/workspace/reference/compatibility.md
@@ -1,163 +1,45 @@
 ---
-title: "tmuxp compatibility and port status"
-description: "Current local CLI capabilities, remaining gaps, and the historical builder audit."
+title: Runtime and configuration support
+description: Runtime requirements and configuration boundaries for the .NET workspace command.
 port: dotnet
 product: workspace
 sidebar:
-  label: "tmuxp compatibility and port status"
+  label: Runtime and configuration support
   group: "Reference"
   order: 30
 tableOfContents: true
 ---
 
-**Local implementation, unpublished.** The .NET `tmux-workspace` CLI
-is available in the `workspace-cli` source worktree. Its command and
-configuration coverage remains partial. See [installation](../../guides/installation/)
-for local setup; installing a published library does not establish availability
-of this CLI.
+`tmux-workspace` is the .NET command for loading and capturing tmux
+workspaces. The [installation guide](../../guides/installation/) builds the
+documented source revision and runs a session on a private socket. The
+walkthroughs require tmux 3.2a or newer.
 
-Compatibility targets useful tmuxp 1.74.0 commands and workspace workflows, with
-native validation, execution and output conventions. Matching command names does
-not promise identical runtime behavior or Python semantics.
+## Runtime and execution
 
-## This port
+The CLI has .NET 8 and .NET 10 builds. Keep the selected runtime available,
+or install the packaged .NET tool. Native services handle loading, capture,
+discovery, search, conversion, import and editing.
 
-Native services cover load, capture, discovery, search, conversion, both
-importers, editor execution and diagnostics on Unix. Loading creates or reuses
-an exact session name. Append authenticates the inherited daemon and selected
-endpoint, resolves the pane's current session through tmux and retains that
-session across all inputs. Moving the pane does not redirect later inputs;
-the session suffix in `TMUX` does not select the destination. Later commands,
-including global options after a script, reject a replacement daemon. Failure
-preserves the borrowed session. A session-name override applies to the final
-input. Partial results identify completed inputs and retained changes.
+Plugins, custom builders and `shell` use an optional interpreter with tmuxp
+1.74.0. Set `TMUX_WORKSPACE_PYTHON` to select it. Use detached loading for
+extension workspaces when terminal handoff is unavailable.
 
-Panes retain configuration order, including windows with three or more panes.
-`pane-base-index` changes their starting index; explicit focus selects the
-configured pane without changing that order.
+`LibTmux.Workspace` is a separate library API. Its parser and builder contract
+does not define every configuration feature accepted by the CLI.
 
-Native imports validate the translated workspace before printing or saving.
-Teamocil command groups, window options and first-requested focus are preserved;
-tmuxinator shorthand command lists stay in one pane, while explicit pane lists
-create separate panes. Synchronization preserves before/after command timing.
-Unsupported launcher hooks, project `pre`, Teamocil filters or `clear`, and
-named tmuxinator pane titles are refused before writing a destination. See
-[imports](../../cli/import/#native-net-imports) for supported shapes and roots.
+## Configuration and failure handling
 
-The normalizer supports command shorthand, inherited commands, enter/delay
-settings, history suppression, directories, environment, shells, layouts,
-indexes, focus and options. Before-scripts run direct argv after session
-creation, from the explicit session directory or invocation directory. Failure
-removes only the created session. Blank panes skip readiness work. Capture
-retains topology, directories, window options and current command names, but
-cannot recover original arguments, history, hooks or plugin state.
+Read [configuration](../../configuration/) for the CLI's fields. Unsupported
+execution fields fail visibly; generic [conversion](../../cli/convert/)
+preserves document values without proving that they can be executed.
 
-Every command accepts `--json` and `--ndjson`; NDJSON takes precedence. Machine
-load requires `-d` or explicit append and never prompts. Machine document
-commands avoid guessed output filenames. `--save-to` selects a destination and
-`--force` permits replacement through atomic publication. Human output uses
-semantic colors, with machine diagnostics on stderr. Search uses native .NET
-regular expressions with a one-second match timeout.
+Use [machine output](../output/) for automation and check both the process
+status and any retained effects. Capture reads live tmux state; it cannot
+recover original command arguments, scripts, comments or application state.
 
-Human `ls --full` shows windows, layouts and each pane's first command in a
-tree. Literal markup and terminal controls remain escaped. JSON retains the
-full decoded configuration.
+[Examples](../../examples/gallery/) provide complete starter documents. Their
+pane commands can need additional applications and directories when adapted.
+Use [library internals](../../internals/) for the programmatic builder.
 
-Native load rejects `-8` and `--88-colors` before reading workspace files or
-running tmux or Python. Supported tmux versions cannot provide 88-color mode;
-use `-2` for 256 colors.
-
-`--log-level` filters optional warnings and file records without suppressing
-command errors. On Linux x64, `load --log-file` appends structured logs and
-rejects unusable destinations before tmux or Python runs. A later file failure
-disables logging and remains secondary to the workspace result, error or
-cancellation. See [output](../output/) for levels and file restrictions.
-
-Human load renders terminal progress on stderr on Linux x64. Presets and bare
-named token templates track configured windows and panes. Pane completion means
-commands were delivered and configured delays elapsed, not that shell commands
-finished. Script panels retain a bounded tail; disabling the panel preserves
-the original stdout/stderr destinations. Resizing stops drawing and leaves the
-old frame in place. See [load](../../cli/load/#progress-and-script-output).
-
-Human load supports attachment and client-selection prompts on a foreground
-controlling terminal on Linux x64. It authenticates the invoking pane and
-daemon before building and rechecks the selected client before handoff.
-SIGINT and SIGTERM report cancellation. See
-[native attachment](../../cli/load/#native-net-attachment) for prompt choices
-and late failures.
-
-Python shell and workspace extensions use a checked tmuxp 1.74.0 runtime
-selected by `TMUX_WORKSPACE_PYTHON`. Append with Python plugins or custom
-builders fails before building any input or starting Python; use `-d` to load
-those extensions into a separate session. Empty `plugins: []` and a null
-`workspace_builder` remain native. Child stdout and stderr are captured
-separately with bounds and explicit truncation. The parser generates Markdown,
-command metadata, a manual and static Bash/Zsh/Fish completion definitions.
-
-The [native CLI source reference](https://github.com/libtmux/libtmux-dotnet/blob/4ac82a5b82fd8cf68d31c70a2a3eb43c587cd7c0/src/LibTmux.Workspace.Cli/README.md)
-describes this development implementation. Use the native executable's `--help`
-for the options implemented in that checkout.
-
-### Remaining gaps
-
-- Progress drawing is limited to Linux x64 and does not redraw after a
-  terminal resize.
-- .NET Console initialization can emit keypad controls when stdout is a
-  terminal. Console writes do not have a hard cancellation deadline; see
-  [output](../output/).
-- Attached Python extension handoff remains unavailable; use `-d` for those
-  extensions. Controlling-terminal editor/shell behavior and other platforms
-  still need their remaining terminal and interruption gates.
-- Python plugin loading delegates the whole load rather than preserving native
-  per-input accounting. Optional backends and extension lifecycle coverage
-  remain incomplete.
-- Contextual completion, YAML alias/depth and configuration corpus coverage,
-  full capture and platform/package acceptance remain open.
-
-## Historical builder audit
-
-Audit date: 2026-09-09. [Native source snapshot](https://github.com/libtmux/libtmux-dotnet/tree/b71b9654f41785c93717e454cbf176672b3d634a).
-The following results describe that original library revision, before the local
-CLI implementation. They are historical evidence, not its current capability
-list or a support guarantee for a published artifact.
-
-The library parsed 7 upstream YAML examples in the original audit. Existing
-builder tests passed, but full normalization, command services and capture were
-incomplete. Window options were applied after commands. The source snapshot had
-no native CLI.
-
-At that baseline, `LibTmux.Workspace` rejected unknown or duplicate keys and
-unsupported value shapes. Its parser and builder covered a subset, and build
-errors could expose a partial result without automatic rollback. Those
-historical library results are separate from current CLI validation and owned
-session cleanup.
-
-Read the port's [builder topics](../../internals/topics/) and
-[API](../) for its library interface. Use the language switcher
-to compare the same topic across ports; each port has its own coverage limits.
-
-## Shared gaps
-
-Parser acceptance does not prove execution support. Native regex engines and
-Python plugin runtimes have different contracts; identical flags alone do not
-establish compatibility. See [shell](../../cli/shell/),
-[search](../../cli/search/) and [hooks](../../configuration/hooks/), and apply
-this port's current limitations above when reading those reference pages.
-
-## Optional format separator
-
-Python libtmux exposes `LIBTMUX_TMUX_FORMAT_SEPARATOR` in its format collector.
-This native CLI does not claim that setting as a supported codec control. Its
-framing and decoding need their own compatible seam and collision, empty value,
-Unicode and line-break checks before accepting such a setting.
-
-## Reading examples
-
-The [gallery](../../examples/gallery/) contains the upstream fixture corpus.
-Parsing a fixture and executing its applications are separate checks. Several
-require external programs, remote hosts, project directories or plugin
-packages. A successful YAML read does not establish those dependencies or the
-complete workspace behavior.
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+[CLI source](https://github.com/libtmux/libtmux-dotnet/blob/f77fe776ba67a04abb20ddbbc26cf4a000d63b74/src/LibTmux.Workspace.Cli/README.md).
diff --git a/site/src/content/docs/ports/go/examples/capture-pane-output.md b/site/src/content/docs/ports/go/examples/capture-pane-output.md
new file mode 100644
index 00000000..ee6968b6
--- /dev/null
+++ b/site/src/content/docs/ports/go/examples/capture-pane-output.md
@@ -0,0 +1,156 @@
+---
+port: go
+route: examples/capture-pane-output
+title: Capture pane output
+description: Run a complete program that captures a pane and waits for a complete output line.
+sidebar:
+  label: Capture pane output
+  group: Examples
+  order: 3
+tableOfContents: true
+---
+
+A pane runs asynchronously: sending a command does not mean its output is
+already on screen. Capture repeatedly until the expected line appears, with a
+deadline so a failed command cannot leave the program waiting forever.
+
+This complete program creates a private tmux server, captures its output, and
+cleans up. Follow the [setup and run instructions](#setup-and-run) below. You need
+tmux and a Unix environment; no existing tmux session is required.
+
+## Read what's on screen
+
+The program sends `printf` with a leading newline, then waits for the complete
+line `libtmux capture ready`. The newline keeps a late shell prompt off that
+line. Matching the whole line avoids mistaking the echoed command for its output.
+
+```go title="main.go"
+package main
+
+import (
+  "context"
+  "errors"
+  "fmt"
+  "log"
+  "os"
+  "path/filepath"
+  "time"
+
+  "github.com/libtmux/libtmux-go/tmux"
+)
+
+func main() {
+  if err := capture(); err != nil {
+    log.Fatal(err)
+  }
+}
+
+func capture() (err error) {
+  directory, err := os.MkdirTemp("", "libtmux-capture-")
+  if err != nil {
+    return err
+  }
+  server, err := tmux.NewServer(tmux.ServerOptions{
+    SocketPath: filepath.Join(directory, "tmux.sock"),
+    ConfigFile: "/dev/null",
+  })
+  if err != nil {
+    return errors.Join(err, os.RemoveAll(directory))
+  }
+  defer func() {
+    cleanup, stop := context.WithTimeout(context.Background(), time.Second)
+    defer stop()
+    if cleanupErr := server.Kill(cleanup); cleanupErr != nil {
+      err = errors.Join(err, fmt.Errorf("stop private server at %s: %w",
+        filepath.Join(directory, "tmux.sock"), cleanupErr))
+      return
+    }
+    err = errors.Join(err, os.RemoveAll(directory))
+  }()
+  ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+  defer cancel()
+  if _, err = server.NewSession(ctx, tmux.NewSessionRequest{
+    Name: "capture", Command: "sh",
+    Environment: map[string]string{"ENV": "/dev/null"},
+  }); err != nil {
+    return err
+  }
+  panes, err := server.Panes(ctx)
+  if err != nil {
+    return err
+  }
+  if len(panes) == 0 {
+    return errors.New("the session has no pane")
+  }
+  pane := panes[0]
+  command := "printf '\\nlibtmux capture ready\\n'"
+  if err := pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &command}); err != nil {
+    return err
+  }
+  for {
+    lines, err := pane.Capture(ctx, tmux.CapturePaneRequest{})
+    if err != nil {
+      return err
+    }
+    for _, line := range lines {
+      if line == "libtmux capture ready" {
+        fmt.Println(line)
+        return nil
+      }
+    }
+    select {
+    case <-ctx.Done():
+      return ctx.Err()
+    case <-time.After(20 * time.Millisecond):
+    }
+  }
+}
+```
+
+Cleanup is registered before session creation. If stopping tmux fails, the error
+reports the retained socket path so the server remains reachable.
+
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
+
+## Wait for output or completion
+
+The program above checks the captured screen for up to five seconds. The short
+pause between checks limits polling; the observed output determines when the loop
+finishes. A tmux capture is a view of the screen and scrollback, so it can miss
+output that has already scrolled away. Use a stream or a completion signal for
+long-running commands when that distinction matters.
+
+[Capturing output](/guides/capturing-output/) covers capture options, while
+[Sending keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site)
+explains why sending and waiting are separate operations.
+
+## Setup and run
+
+Use an empty directory. The commands pin the library
+revision used to verify the program.
+
+Save the program and module file using the displayed names. Use Go 1.26 or newer.
+
+```text title="go.mod"
+module example.com/capture
+
+go 1.26.0
+
+require github.com/libtmux/libtmux-go v0.0.0
+
+replace github.com/libtmux/libtmux-go => ./libtmux
+```
+
+```console
+$ git clone https://github.com/libtmux/libtmux-go libtmux &&
+  git -C libtmux checkout bb06e26e116e941813ca40bf45e7e3a47d38f52a &&
+  GOWORK=off go mod tidy &&
+  GOWORK=off go run .
+```
+
+<a id="source-inclusion"></a>
+
+## Where this comes from
+
+This complete program was run against the library revision pinned above.
+The displayed code is checked against the bytes from that run.
diff --git a/site/src/content/docs/ports/go/workspace/internals/index.md b/site/src/content/docs/ports/go/workspace/internals/index.md
index 19cd95c2..aadd5366 100644
--- a/site/src/content/docs/ports/go/workspace/internals/index.md
+++ b/site/src/content/docs/ports/go/workspace/internals/index.md
@@ -10,9 +10,9 @@ sidebar:
 tableOfContents: true
 ---
 
-These pages document the in-development workspace builder for contributors
-and applications that call its APIs. For workspace loading from a terminal,
-see [tmuxp](https://tmuxp.git-pull.com/).
+Build and inspect tmux sessions from application code with the workspace
+library. To load files from a terminal, start with the
+[native CLI walkthrough](../guides/installation/).
 
 ## Builder pipeline
 
@@ -30,7 +30,7 @@ reading, deadlines, command-line handling, and attachment.
 
 ## Implementation scope
 
-The `workspace` module parses [tmuxp](https://tmuxp.git-pull.com)-style YAML
+The `workspace` module parses YAML
 and builds a session through libtmux's Go API. It is a separate module, so
 applications using only the core client do not acquire a YAML dependency.
 
@@ -44,9 +44,8 @@ Import [`github.com/libtmux/libtmux-go/workspace`](https://pkg.go.dev/github.com
 package. Building requires tmux on the host. Parsing and configuration
 validation do not start a tmux server.
 
-The module supports tmuxp field names for windows, panes, commands, options,
-environment variables, and working directories. Python plugins and
-`before_script` are rejected. Inspect the supported subset when moving an
-existing Python workspace to Go.
+The module accepts windows, panes, commands, options, environment variables
+and working directories. Plugin declarations and `before_script` are rejected.
+Check the [configuration contract](./topics/) before loading an existing file.
 
 [Workspace module documentation](https://github.com/libtmux/libtmux-go/blob/5f808882015a975a65acc7f9da5b3ff0d5cbdc91/workspace/README.md)
diff --git a/site/src/content/docs/ports/go/workspace/internals/topics.md b/site/src/content/docs/ports/go/workspace/internals/topics.md
index f23af2ba..c0625286 100644
--- a/site/src/content/docs/ports/go/workspace/internals/topics.md
+++ b/site/src/content/docs/ports/go/workspace/internals/topics.md
@@ -43,7 +43,7 @@ commands will resolve.
 
 ## Format differences
 
-Python plugins and `before_script` are rejected. `${VAR}` interpolation is
+Plugin declarations and `before_script` are rejected. `${VAR}` interpolation is
 not performed before building; render such configuration yourself if needed.
 `sleep_before` and `sleep_after` are seconds and pause construction between
 command deliveries.
diff --git a/site/src/content/docs/ports/go/workspace/reference/compatibility.md b/site/src/content/docs/ports/go/workspace/reference/compatibility.md
index 615186c1..ac9e9352 100644
--- a/site/src/content/docs/ports/go/workspace/reference/compatibility.md
+++ b/site/src/content/docs/ports/go/workspace/reference/compatibility.md
@@ -1,161 +1,49 @@
 ---
-title: "tmuxp compatibility and port status"
-description: "Current local CLI capabilities, remaining gaps, and the historical builder audit."
+title: Runtime and configuration support
+description: Runtime requirements and configuration boundaries for the Go workspace command.
 port: go
 product: workspace
 sidebar:
-  label: "tmuxp compatibility and port status"
+  label: Runtime and configuration support
   group: "Reference"
   order: 30
 tableOfContents: true
 ---
 
-**Local implementation, unpublished.** The Go `tmux-workspace` CLI
-is available in the `workspace-cli` source worktree. Its command and
-configuration coverage remains partial. See [installation](../../guides/installation/)
-for local setup; installing a published library does not establish availability
-of this CLI.
+`tmux-workspace` is the Go command for loading and capturing tmux
+workspaces. The [installation guide](../../guides/installation/) builds the
+documented source revision and runs a session on a private socket. The
+walkthroughs require tmux 3.2a or newer.
 
-Compatibility targets useful tmuxp 1.74.0 commands and workspace workflows, with
-native validation, execution and output conventions. Matching command names does
-not promise identical runtime behavior or Python semantics.
+## Runtime and execution
 
-## This port
+Build with Go 1.26 or newer from the repository root so its workspace modules
+are selected together. Ordinary loading, capture, discovery, conversion,
+import and search use native Go services.
 
-Native services cover load, capture, discovery, search, conversion, both
-importers, editor execution and diagnostics. Load creates or reuses a session,
-or appends to the current pane's session. Human foreground loading offers
-switch/detach/append choices inside tmux and requires terminal stdin. Machine
-load requires `-d` or `--append` and does not prompt. Native before-script
-arguments validate for all inputs before session mutation. A failed native
-script removes an owned newly created session and preserves a borrowed append
-session. With several inputs, `load -s` changes only the final workspace's
-session name; earlier inputs retain their configured names in native and
-Python-bridge execution.
+Search uses Go regular expressions. `--regex-engine python` explicitly selects
+the optional Python regex backend. Plugins, custom builders and `shell` need
+tmuxp 1.74.0 in the interpreter selected by `TMUX_WORKSPACE_PYTHON`.
 
-Before foreground loading, the CLI opens the controlling terminal outside
-tmux, or verifies the inherited server, pane and input terminal inside tmux.
-Switching requires one identifiable terminal client viewing that pane. Multiple
-matching clients and independent `active-pane` clients on the same physical
-window require detached or append mode. The selected client's identity and
-attachment are checked again before switching.
+Extension append refuses a document containing `before_script`; native
+scripted append remains supported. Inspect retained effects before retrying
+extension failures.
 
-Progress stops and both output streams are flushed before handoff. A failed
-prompt flush stops before input is read. Handoff failures retain completed
-workspace results for diagnostics. These checks do not make the later tmux
-client-name operation atomic with client replacement.
+The Go workspace library has a separate parser and builder contract. In
+particular, its accepted fields and variable expansion differ from the CLI.
 
-Append checks the inherited server PID and selected socket before checking
-Python. Socket paths may contain commas. It retains one session across all
-inputs even if a script moves the invoking pane; linked panes use tmux's
-canonical session. Native build entry rechecks that retained session before
-running a before script, and subsequent commands retain the core's daemon
-replacement checks.
+## Configuration and failure handling
 
-Legacy `-8` and `--88-colors` fail before workspace lookup, runtime checks or
-backend mutation. `-2` requests 256-color mode.
+Read [configuration](../../configuration/) for the CLI's fields. Unsupported
+execution fields fail visibly; generic [conversion](../../cli/convert/)
+preserves document values without proving that they can be executed.
 
-The normalizer supports pane and command shorthand, inherited commands,
-sequential enter/delay settings, history suppression, directories, launch-time
-environment, shell overrides, layouts, indexes, focus, options, before-scripts
-and readiness policies. Conversion preserves extension fields. Explicit saves
-use atomic publication and require `--force` for replacement. Capture warns that
-original arguments, history, scripts and plugins cannot be recovered.
+Use [machine output](../output/) for automation and check both the process
+status and any retained effects. Capture reads live tmux state; it cannot
+recover original command arguments, scripts, comments or application state.
 
-Every command accepts `--json` and `--ndjson`; NDJSON takes precedence. Load
-streams sequenced events and a terminal result. Human load has semantic colors
-and terminal progress with presets, custom tokens and bounded script lines.
-Machine output disables terminal rendering. Documentation, command metadata,
-manuals and shell completion can be generated from the command graph.
+[Examples](../../examples/gallery/) provide complete starter documents. Their
+pane commands can need additional applications and directories when adapted.
+Use [library internals](../../internals/) for the programmatic builder.
 
-`ls --tree` groups workspaces by directory in discovery order. `--full` includes
-their YAML configurations. Human names and paths escape terminal controls;
-machine records preserve the underlying values and ignore tree presentation.
-
-SIGINT and SIGTERM cancel active scripts through normal cleanup and return
-status 130. Unix confirmation and destination prompts also cancel while stdin
-remains open, preserving terminal settings. Progress follows terminal resizing.
-
-Native Go logging supports `--log-level` and structured `--log-file` output
-on Unix. Optional diagnostics follow the selected level; mandatory command
-errors and machine results remain visible. A later log write or close failure
-preserves the workspace outcome and attempts at most one optional warning.
-See the [logging contract](../output/#native-go-logging).
-
-Search uses native Go regular expressions with ASCII word boundaries and JSON
-text for structured commands. `--regex-engine python` explicitly selects a
-checked Python runtime for Python regex syntax and representations. Python
-shell, plugin and custom-builder execution checks tmuxp 1.74.0 through
-`TMUX_WORKSPACE_PYTHON`; ordinary native commands do not require that runtime.
-Plugin and custom-builder append use the retained session, including when the
-caller also supplies `-d`. The adapter checks its daemon and session before
-importing extensions and after constructing the builder. A missing or replaced
-target fails without creating a replacement session; errors retain the original
-session ID. These checks do not make later builder execution atomic against
-external server replacement or arbitrary plugin code. Documents without a
-`before_script` key can add windows through that bridge.
-
-The local source reference is workspace/CLI.md. Use the native executable's
-`--help` for the options implemented in that checkout.
-
-### Remaining gaps
-
-- Selecting `plugins`, `workspace_builder` or `workspace_builder_paths` with
-  `--append` and a document `before_script` key is unavailable and fails during
-  preflight, including an empty or null script value.
-  The checked Python builder can delete a borrowed session on script failure;
-  the CLI blocks that combination before runtime checks or session mutation.
-  Native scripted append and plugin append without a document script remain
-  supported.
-- Script lifecycle failures and effects before an input returns from building
-  need additional coverage.
-- Descendant cleanup across platforms, optional Python terminals,
-  complete configuration/importer coverage and installed completion execution
-  remain acceptance gaps.
-
-## Historical builder audit
-
-Audit date: 2026-09-09. [Native source snapshot](https://github.com/libtmux/libtmux-go/tree/bb48780c49652d6b7a17884f19a93c269f04a688).
-The following results describe that original library revision, before the local
-CLI implementation. They are historical evidence, not its current capability
-list or a support guarantee for a published artifact.
-
-The library parsed 20 upstream YAML examples and built 18 in the original audit.
-First-pane environment was applied too late; pane environment and split shell
-inheritance were incomplete. Explicit zero delay could inherit a nonzero value.
-YAML/JSON serialization needed a document-preserving boundary. The source
-snapshot had no native CLI.
-
-At that baseline, the workspace package rejected unknown fields, did not perform
-tmuxp variable expansion or run Python plugins, and could leave partial state
-after a builder error. These historical library limits do not describe the
-current CLI normalizer, document conversion or explicit Python bridge.
-
-Read the port's [builder topics](../../internals/topics/) and
-[API](../) for its library interface. Use the language switcher
-to compare the same topic across ports; each port has its own coverage limits.
-
-## Shared gaps
-
-Parser acceptance does not prove execution support. Native regex engines and
-Python plugin runtimes have different contracts; identical flags alone do not
-establish compatibility. See [shell](../../cli/shell/),
-[search](../../cli/search/) and [hooks](../../configuration/hooks/), and apply
-this port's current limitations above when reading those reference pages.
-
-## Optional format separator
-
-Python libtmux exposes `LIBTMUX_TMUX_FORMAT_SEPARATOR` in its format collector.
-This native CLI does not claim that setting as a supported codec control. Its
-framing and decoding need their own compatible seam and collision, empty value,
-Unicode and line-break checks before accepting such a setting.
-
-## Reading examples
-
-The [gallery](../../examples/gallery/) contains the upstream fixture corpus.
-Parsing a fixture and executing its applications are separate checks. Several
-require external programs, remote hosts, project directories or plugin
-packages. A successful YAML read does not establish those dependencies or the
-complete workspace behavior.
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+[CLI source](https://github.com/libtmux/libtmux-go/blob/bb06e26e116e941813ca40bf45e7e3a47d38f52a/workspace/CLI.md).
diff --git a/site/src/content/docs/ports/java/examples/capture-pane-output.md b/site/src/content/docs/ports/java/examples/capture-pane-output.md
new file mode 100644
index 00000000..5f85f67e
--- /dev/null
+++ b/site/src/content/docs/ports/java/examples/capture-pane-output.md
@@ -0,0 +1,108 @@
+---
+port: java
+route: examples/capture-pane-output
+title: Capture pane output
+description: Run a complete program that captures a pane and waits for a complete output line.
+sidebar:
+  label: Capture pane output
+  group: Examples
+  order: 3
+tableOfContents: true
+---
+
+A pane runs asynchronously: sending a command does not mean its output is
+already on screen. Capture repeatedly until the expected line appears, with a
+deadline so a failed command cannot leave the program waiting forever.
+
+This complete program creates a private tmux server, captures its output, and
+cleans up. Follow the [setup and run instructions](#setup-and-run) below. You need
+tmux and a Unix environment; no existing tmux session is required.
+
+## Read what's on screen
+
+The program sends `printf` with a leading newline, then waits for the complete
+line `libtmux capture ready`. The newline keeps a late shell prompt off that
+line. Matching the whole line avoids mistaking the echoed command for its output.
+
+```java title="Capture.java"
+import io.github.libtmux.Pane;
+import io.github.libtmux.Server;
+import io.github.libtmux.ServerConfig;
+import io.github.libtmux.ServerEndpoint;
+import io.github.libtmux.Session;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.List;
+
+public final class Capture {
+    public static void main(String[] args) throws Exception {
+        Path directory = Files.createTempDirectory("libtmux-capture-");
+        Path socket = directory.resolve("tmux.sock");
+        ServerConfig config = ServerConfig.builder()
+                .endpoint(ServerEndpoint.socketPath(socket))
+                .configFile(Path.of("/dev/null"))
+                .defaultTimeout(Duration.ofSeconds(1))
+                .build();
+        try (Server server = Server.open(config)) {
+            try {
+                Session session = server.newSession(s -> s
+                        .named("capture").running("sh").env("ENV", "/dev/null"));
+                Pane pane = session.windows().get(0).panes().get(0);
+                pane.sendLine("printf '\\nlibtmux capture ready\\n'");
+                long deadline = System.nanoTime() + Duration.ofSeconds(5).toNanos();
+                while (System.nanoTime() < deadline) {
+                    List<String> lines = pane.capture();
+                    if (lines.contains("libtmux capture ready")) {
+                        System.out.println("libtmux capture ready");
+                        return;
+                    }
+                    Thread.sleep(20);
+                }
+                throw new IllegalStateException("Timed out waiting for pane output");
+            } finally {
+                server.killServer();
+            }
+        } finally {
+            Files.deleteIfExists(socket);
+            Files.delete(directory);
+        }
+    }
+}
+```
+
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
+
+## Wait for output or completion
+
+The program above checks the captured screen for up to five seconds. The short
+pause between checks limits polling; the observed output determines when the loop
+finishes. A tmux capture is a view of the screen and scrollback, so it can miss
+output that has already scrolled away. Use a stream or a completion signal for
+long-running commands when that distinction matters.
+
+[Capturing output](/guides/capturing-output/) covers capture options, while
+[Sending keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site)
+explains why sending and waiting are separate operations.
+
+## Setup and run
+
+Use an empty directory. The commands pin the library
+revision used to verify the program.
+
+Save the program as `Capture.java`. Use JDK 21 or newer. The repository's Gradle
+wrapper builds the library; the Java source launcher runs the complete program.
+
+```console
+$ git clone https://github.com/libtmux/libtmux-java libtmux &&
+  git -C libtmux checkout 842228310449e879ebcaa3f910597757c9dbffd6 &&
+  (cd libtmux && ./gradlew :libtmux:jar) &&
+  java --class-path 'libtmux/libtmux/build/libs/*' Capture.java
+```
+
+<a id="source-inclusion"></a>
+
+## Where this comes from
+
+This complete program was run against the library revision pinned above.
+The displayed code is checked against the bytes from that run.
diff --git a/site/src/content/docs/ports/java/workspace/internals/examples.md b/site/src/content/docs/ports/java/workspace/internals/examples.md
index 904742bb..012962c6 100644
--- a/site/src/content/docs/ports/java/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/java/workspace/internals/examples.md
@@ -10,50 +10,118 @@ sidebar:
 tableOfContents: true
 ---
 
-The module README builds a session with two windows and verifies the returned
-window and pane counts. The port's `docs-tests` project collects Java README
-fences and runs them against real tmux.
-
-## Build a described layout
-
-Within an application that already has a `Server`, import `Workspace` and
-`WorkspaceBuilder` from [`io.github.libtmux.workspace`](https://github.com/libtmux/libtmux-java/tree/4f057d367a25dee818d70876fa283fc503a3a7eb/libtmux-workspace/src/main/java/io/github/libtmux/workspace), and `Session` from
-[`io.github.libtmux`](../../../reference/). This excerpt uses the same configuration as the module's
-result example:
-
-```java
-Workspace workspace = WorkspaceBuilder.parse("""
-        session_name: built
-        windows:
-          - window_name: editor
-            layout: even-horizontal
-            panes:
-              - shell_command: echo one
-              - shell_command: echo two
-          - window_name: server
-            panes:
-              - echo three
-        """);
-Session session = WorkspaceBuilder.build(server, workspace);
-System.out.println(session.windows().size());
-System.out.println(session.windows().get(0).panes().size());
+Build a two-window workspace, inspect its panes, and remove the private tmux
+server. Use a POSIX host with tmux on `PATH` and JDK 25.
+
+## Create the project
+
+In a new directory, fetch the source revision used by this documentation:
+
+```console
+$ mkdir java-workspace-example
+$ cd java-workspace-example
+$ git init -q libtmux-source
+$ git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-java.git
+$ git -C libtmux-source fetch --depth=1 origin 842228310449e879ebcaa3f910597757c9dbffd6
+$ git -C libtmux-source checkout --detach FETCH_HEAD
+$ mkdir -p src/main/java
+```
+
+Save the following settings file. The included build supplies the workspace
+module and its core dependency from the selected source. Its toolchain resolver
+downloads the Temurin 21 compiler for those libraries when needed.
+
+```kotlin title="settings.gradle.kts"
+rootProject.name = "workspace-example"
+includeBuild("libtmux-source")
 ```
 
-The output is two windows and two panes in the first window. Use the
-[guide](../guides/) for the complete server setup and cleanup. The builder
-creates a new session, so the requested name must be available.
+Save the following build file:
+
+```kotlin title="build.gradle.kts"
+plugins {
+    application
+}
 
-## Verification
+repositories {
+    mavenCentral()
+}
 
-From a prepared source checkout, run the documentation example project:
+dependencies {
+    implementation("io.github.libtmux:libtmux-workspace:0.0.1-alpha.12-SNAPSHOT")
+}
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(25))
+}
+
+application {
+    mainClass.set("WorkspaceExample")
+}
+```
+
+## Build and inspect
+
+Save this complete program as `src/main/java/WorkspaceExample.java`:
+
+```java title="src/main/java/WorkspaceExample.java"
+import io.github.libtmux.Server;
+import io.github.libtmux.ServerEndpoint;
+import io.github.libtmux.Session;
+import io.github.libtmux.workspace.Workspace;
+import io.github.libtmux.workspace.WorkspaceBuilder;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.UUID;
+
+public final class WorkspaceExample {
+    public static void main(String[] args) {
+        Workspace workspace = WorkspaceBuilder.parse("""
+                session_name: built
+                windows:
+                  - window_name: editor
+                    layout: even-horizontal
+                    panes:
+                      - shell_command: echo one
+                      - shell_command: echo two
+                  - window_name: server
+                    panes:
+                      - echo three
+                """);
+        try (Server server = Server.builder()
+                .endpoint(ServerEndpoint.namedSocket("workspace-" + UUID.randomUUID()))
+                .configFile(Path.of("/dev/null"))
+                .defaultTimeout(Duration.ofSeconds(10))
+                .build()) {
+            try {
+                server.newSession("bootstrap");
+                Session session = WorkspaceBuilder.build(server, workspace);
+                System.out.println(session.name() + ": " + session.windows().size() + " windows");
+                System.out.println("editor: " + session.windows().getFirst().panes().size() + " panes");
+            } finally {
+                server.killServer();
+            }
+        }
+    }
+}
+```
+
+Use the checked-out Gradle wrapper to run the application:
 
 ```console
-$ ./gradlew :docs-tests:test
+$ ./libtmux-source/gradlew --no-daemon --max-workers=2 -p . run
 ```
 
-The module README also exercises invalid layouts and creating a workspace
-beside an existing unrelated session. Those checks cover configuration
-behavior; they do not prove that arbitrary commands launched in a pane have
-finished or become ready.
+The application prints `built: 2 windows` and `editor: 2 panes`. Its unique
+socket prevents a collision with an existing server. The `finally` block
+removes that server even if construction or inspection fails. Closing the
+Java handle then releases its transport.
+
+The bootstrap session starts tmux before the workspace builder checks its
+version. It belongs to the same private server and is removed with it.
+
+Building creates the layout and sends the pane commands. It does not wait for
+those programs to finish. Keep the session running instead of calling
+`killServer` when adapting this example into an application launcher.
 
-[Collected README examples](https://github.com/libtmux/libtmux-java/blob/4f057d367a25dee818d70876fa283fc503a3a7eb/libtmux-workspace/README.md)
+[Workspace API source](https://github.com/libtmux/libtmux-java/tree/842228310449e879ebcaa3f910597757c9dbffd6/libtmux-workspace/src/main/java/io/github/libtmux/workspace)
diff --git a/site/src/content/docs/ports/java/workspace/internals/index.md b/site/src/content/docs/ports/java/workspace/internals/index.md
index 0272278a..6d9da761 100644
--- a/site/src/content/docs/ports/java/workspace/internals/index.md
+++ b/site/src/content/docs/ports/java/workspace/internals/index.md
@@ -10,9 +10,9 @@ sidebar:
 tableOfContents: true
 ---
 
-These pages document the in-development workspace builder for contributors
-and applications that call its APIs. For workspace loading from a terminal,
-see [tmuxp](https://tmuxp.git-pull.com/).
+Build and inspect tmux sessions from application code with the workspace
+library. To load files from a terminal, start with the
+[native CLI walkthrough](../guides/installation/).
 
 ## Builder pipeline
 
@@ -34,8 +34,8 @@ command-line handling, attachment, and the server connection.
 libtmux's Java API and returns the session after capturing the completed
 window and pane structure.
 
-The module supports a focused [tmuxp](https://tmuxp.git-pull.com) subset:
-session names, windows, layouts, panes, and ordered shell commands. It rejects
+The module accepts session names, windows, layouts, panes and ordered shell
+commands. It rejects
 unknown configuration fields instead of accepting a larger file with missing
 behavior.
 
@@ -45,8 +45,4 @@ Use the [`io.github.libtmux:libtmux-workspace`](https://central.sonatype.com/art
 The module targets Java 21 and requires tmux on the host for building. Parsing
 YAML does not create a session.
 
-This module does not load Python plugins or implement tmuxp's CLI. Use the
-[Python workspace documentation](https://tmuxp.git-pull.com/) when those
-features are required.
-
 [Module documentation](https://github.com/libtmux/libtmux-java/blob/4f057d367a25dee818d70876fa283fc503a3a7eb/libtmux-workspace/README.md)
diff --git a/site/src/content/docs/ports/java/workspace/reference.md b/site/src/content/docs/ports/java/workspace/reference.md
index 2ab7a5bf..c9804822 100644
--- a/site/src/content/docs/ports/java/workspace/reference.md
+++ b/site/src/content/docs/ports/java/workspace/reference.md
@@ -36,8 +36,7 @@ holds the name, optional layout, and panes.
 holds the ordered shell commands.
 
 These records copy their lists so later changes to an input list do not alter
-a description already constructed. They describe the supported Java subset;
-they are not Python plugin or tmuxp runtime extension interfaces.
+a description already constructed.
 
 ## Errors and lifetime
 
diff --git a/site/src/content/docs/ports/java/workspace/reference/compatibility.md b/site/src/content/docs/ports/java/workspace/reference/compatibility.md
index 1e3b557a..cb3958bb 100644
--- a/site/src/content/docs/ports/java/workspace/reference/compatibility.md
+++ b/site/src/content/docs/ports/java/workspace/reference/compatibility.md
@@ -1,138 +1,45 @@
 ---
-title: "tmuxp compatibility and port status"
-description: "Current local CLI capabilities, remaining gaps, and the historical builder audit."
+title: Runtime and configuration support
+description: Runtime requirements and configuration boundaries for the Java workspace command.
 port: java
 product: workspace
 sidebar:
-  label: "tmuxp compatibility and port status"
+  label: Runtime and configuration support
   group: "Reference"
   order: 30
 tableOfContents: true
 ---
 
-**Local implementation, unpublished.** The Java `tmux-workspace` CLI
-is available in the `workspace-cli` source worktree. Its command and
-configuration coverage remains partial. See [installation](../../guides/installation/)
-for local setup; installing a published library does not establish availability
-of this CLI.
+`tmux-workspace` is the Java command for loading and capturing tmux
+workspaces. The [installation guide](../../guides/installation/) builds the
+documented source revision and runs a session on a private socket. The
+walkthroughs require tmux 3.2a or newer.
 
-Compatibility targets useful tmuxp 1.74.0 commands and workspace workflows, with
-native validation, execution and output conventions. Matching command names does
-not promise identical runtime behavior or Python semantics.
+## Runtime and execution
 
-## This port
+Use JDK 25 or newer. Keep the generated application distribution together;
+its launcher depends on the adjacent libraries. Native services handle loading,
+capture, discovery, search, conversion, import and editing.
 
-Native services cover load, capture, discovery, search, conversion, both
-importers, editor execution and diagnostics. Loading creates or reuses a
-session; append authenticates the inherited tmux daemon and keeps the original
-session across input files even if a script moves the invoking pane. Attached
-load uses the controlling terminal and an authenticated invoking client/server.
-Failure results identify retained effects rather than promising rollback.
+Plugins, custom builders and `shell` need the optional tmuxp 1.74.0 environment
+selected by `TMUX_WORKSPACE_PYTHON`. Extension append refuses a document
+containing `before_script` to preserve its borrowed session on failure.
 
-The normalizer supports command shorthand and sequential enter/delay settings,
-directories, environment, shell overrides, layouts, indexes, focus, options,
-before-scripts and readiness policies. Blank panes and explicit launch commands
-skip readiness checks. Unsupported configuration keys fail before tmux access.
-YAML aliases and merges expand with depth/value bounds; strict JSON rejects YAML
-syntax. Conversion preserves extension fields. Capture recovers topology,
-directories, focus and configured options, but cannot recover command history,
-bootstrap scripts or plugin intent. Search uses native Java regular expressions.
+The CLI validates execution fields before changing tmux. Use the separate
+workspace library reference when constructing sessions from Java code.
 
-Loading checks layouts across all inputs before setup scripts or topology
-changes. Named layouts accept unique abbreviations supported by the running
-daemon; only a cold endpoint falls back to the selected client's version.
-Serialized layouts have bounded checksum, tree and pane-count validation.
-Tmux remains responsible for geometry correction and pruning.
+## Configuration and failure handling
 
-Every command accepts `--json` and `--ndjson`, with NDJSON taking precedence.
-Load and child output stream as escaped events. Human output has semantic
-colors; log levels and load log files keep diagnostics separate from results.
-Interruptions have bounded final-output delivery and can leave an incomplete
-stream. `load -2` selects 256-color mode; `-8` fails before workspace lookup.
-The parser can generate command metadata and Bash completion.
+Read [configuration](../../configuration/) for the CLI's fields. Unsupported
+execution fields fail visibly; generic [conversion](../../cli/convert/)
+preserves document values without proving that they can be executed.
 
-Human load progress updates from events on terminal stderr. Five presets and
-custom templates are supported; `--progress-lines` bounds the script panel,
-with 3 rows by default, 0 hiding it and -1 using available initial terminal
-height. Script streams keep their original destinations. Machine output,
-redirected stderr, `TERM=dumb`, `--no-progress` and `TMUXP_PROGRESS=0` disable
-the display. Completion and interruption clear the frame.
+Use [machine output](../output/) for automation and check both the process
+status and any retained effects. Capture reads live tmux state; it cannot
+recover original command arguments, scripts, comments or application state.
 
-Python shell and workspace extension execution require an explicitly selected
-`TMUX_WORKSPACE_PYTHON` interpreter with tmuxp 1.74.0. Plugin/custom-builder
-loading checks that runtime before backend mutation and resolves builder imports
-relative to the source document. Extension results identify observed topology;
-they do not infer ownership of sessions returned by custom code. Append keeps
-the authenticated borrowed session even if the invoking pane moves. Extension
-append rejects any document containing `before_script`, including null or empty
-values, because tmuxp can delete the borrowed session when that script fails.
-Opaque extension execution does not emit native per-pane progress.
+[Examples](../../examples/gallery/) provide complete starter documents. Their
+pane commands can need additional applications and directories when adapted.
+Use [library internals](../../internals/) for the programmatic builder.
 
-tmux 3.2a alters literal dollar signs in newly created session names; Python's
-classic builder can fail its name check for those inputs. Ordinary names are
-covered by the current/floor extension tests.
-
-Interactive editors and Python shells use the controlling terminal while machine
-results remain on stdout. Ordinary native load and read commands do not need
-Python.
-
-The local source reference is workspace-cli/README.md. Use the native
-executable's `--help` for the options implemented in that checkout.
-
-### Remaining gaps
-
-- Interactive prompt behavior and broader Python extension coverage remain open.
-- Progress samples terminal dimensions once and does not follow resizing.
-  Unicode clipping is conservative.
-- Complete configuration/importer/capture coverage and full terminal/platform
-  acceptance remain unfinished. Explicit launch commands currently skip
-  readiness even when the policy is `always`.
-- Cancellation of caller-supplied streams that ignore interruption cannot reap
-  their pending write; it may finish later when the caller drains the stream.
-  Non-Linux descendant cleanup needs additional reparenting tests.
-
-## Historical builder audit
-
-Audit date: 2026-09-09. [Native source snapshot](https://github.com/libtmux/libtmux-java/tree/4f057d367a25dee818d70876fa283fc503a3a7eb).
-The following results describe that original library revision, before the local
-CLI implementation. They are historical evidence, not its current capability
-list or a support guarantee for a published artifact.
-
-The library parsed 3 upstream YAML examples in the original audit. Source and
-integration tests passed for its supported builder surface, but starting a
-named-layout workspace on a cold socket could fail. Full normalization and CLI
-services were absent. The source snapshot had no native CLI.
-
-At that baseline, the parser accepted session names/windows, window
-names/layouts/panes and pane commands, and rejected unknown keys. The builder
-used a staging session and attempted cleanup on failure. These observations
-refer to the original library surface, not the current native CLI.
-
-Read the port's [builder topics](../../internals/topics/) and
-[API](../) for its library interface. Use the language switcher
-to compare the same topic across ports; each port has its own coverage limits.
-
-## Shared gaps
-
-Parser acceptance does not prove execution support. Native regex engines and
-Python plugin runtimes have different contracts; identical flags alone do not
-establish compatibility. See [shell](../../cli/shell/),
-[search](../../cli/search/) and [hooks](../../configuration/hooks/), and apply
-this port's current limitations above when reading those reference pages.
-
-## Optional format separator
-
-Python libtmux exposes `LIBTMUX_TMUX_FORMAT_SEPARATOR` in its format collector.
-This native CLI does not claim that setting as a supported codec control. Its
-framing and decoding need their own compatible seam and collision, empty value,
-Unicode and line-break checks before accepting such a setting.
-
-## Reading examples
-
-The [gallery](../../examples/gallery/) contains the upstream fixture corpus.
-Parsing a fixture and executing its applications are separate checks. Several
-require external programs, remote hosts, project directories or plugin
-packages. A successful YAML read does not establish those dependencies or the
-complete workspace behavior.
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+[CLI source](https://github.com/libtmux/libtmux-java/blob/3e5b20d22af3890ae5f7f52842e4b05d170a983f/libtmux-workspace-cli/README.md).
diff --git a/site/src/content/docs/ports/py/examples/capture-pane-output.md b/site/src/content/docs/ports/py/examples/capture-pane-output.md
new file mode 100644
index 00000000..56b25027
--- /dev/null
+++ b/site/src/content/docs/ports/py/examples/capture-pane-output.md
@@ -0,0 +1,93 @@
+---
+port: py
+route: examples/capture-pane-output
+title: Capture pane output
+description: Run a complete program that captures a pane and waits for a complete output line.
+sidebar:
+  label: Capture pane output
+  group: Examples
+  order: 3
+tableOfContents: true
+---
+
+A pane runs asynchronously: sending a command does not mean its output is
+already on screen. Capture repeatedly until the expected line appears, with a
+deadline so a failed command cannot leave the program waiting forever.
+
+This complete program creates a private tmux server, captures its output, and
+cleans up. Follow the [setup and run instructions](#setup-and-run) below. You need
+tmux and a Unix environment; no existing tmux session is required.
+
+## Read what's on screen
+
+The program sends `printf` with a leading newline, then waits for the complete
+line `libtmux capture ready`. The newline keeps a late shell prompt off that
+line. Matching the whole line avoids mistaking the echoed command for its output.
+
+```python title="capture.py"
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from time import monotonic, sleep
+
+import libtmux
+
+with TemporaryDirectory(prefix="libtmux-capture-") as directory:
+    server = libtmux.Server(
+        socket_path=Path(directory) / "tmux.sock",
+        config_file="/dev/null",
+    )
+    try:
+        session = server.new_session(
+            session_name="capture",
+            window_command="sh",
+            environment={"ENV": "/dev/null"},
+        )
+        pane = session.active_window.active_pane
+        pane.send_keys("printf '\\nlibtmux capture ready\\n'", literal=True)
+
+        deadline = monotonic() + 5
+        while True:
+            lines = pane.capture_pane()
+            if "libtmux capture ready" in lines:
+                print("\n".join(lines))
+                break
+            if monotonic() >= deadline:
+                raise TimeoutError("The pane did not print the expected line")
+            sleep(0.05)
+    finally:
+        server.kill()
+```
+
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
+
+## Wait for output or completion
+
+The program above checks the captured screen for up to five seconds. The short
+pause between checks limits polling; the observed output determines when the loop
+finishes. A tmux capture is a view of the screen and scrollback, so it can miss
+output that has already scrolled away. Use a stream or a completion signal for
+long-running commands when that distinction matters.
+
+[Capturing output](/guides/capturing-output/) covers capture options, while
+[Sending keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site)
+explains why sending and waiting are separate operations.
+
+## Setup and run
+
+Use an empty directory. The commands pin the library
+revision used to verify the program.
+
+Save the program as `capture.py`. With Python 3.10 or newer and uv installed:
+
+```console
+$ uv run \
+    --with 'libtmux @ git+https://github.com/tmux-python/libtmux@9fdd083a8181a827889337b63cd4e6daea661a8c' \
+    capture.py
+```
+
+<a id="source-inclusion"></a>
+
+## Where this comes from
+
+This complete program was run against the library revision pinned above.
+The displayed code is checked against the bytes from that run.
diff --git a/site/src/content/docs/ports/py/workspace/reference/compatibility.md b/site/src/content/docs/ports/py/workspace/reference/compatibility.md
index 8d4f3514..fa6b4a74 100644
--- a/site/src/content/docs/ports/py/workspace/reference/compatibility.md
+++ b/site/src/content/docs/ports/py/workspace/reference/compatibility.md
@@ -1,64 +1,41 @@
 ---
-title: "tmuxp compatibility and port status"
-description: "Separate parser acceptance, builder behavior, proposed CLI services, and installed capabilities."
+title: Runtime and configuration support
+description: Runtime, configuration and extension requirements for tmuxp.
 port: py
 product: workspace
 sidebar:
-  label: "tmuxp compatibility and port status"
+  label: Runtime and configuration support
   group: "Reference"
   order: 30
 tableOfContents: true
 ---
 
-This page documents the available Python tmuxp reference. Proposed native
-extensions are labeled separately.
+These pages document tmuxp 1.74.0 at the source revision linked below. Install
+tmuxp in its own Python environment and let its dependency resolver select a
+compatible libtmux release. The walkthroughs use Python 3.10 or newer and
+tmux 3.2a or newer.
 
-The reference is Python tmuxp 1.74.0 at the source revision linked below. A
-native workspace library, parser experiment, and installed CLI are different
-deliverables. None of the seven native ports currently supplies the full
-command-line application described by the compatibility proposal.
+## Configuration and extensions
 
-## This port
+Read [configuration](../../configuration/) for normalization, inheritance,
+directories, commands and hooks. Parsing YAML alone does not establish that
+a field changes builder behavior. Plugins and custom builders execute Python
+code from their installed packages or configured import paths.
 
-Python tmuxp is the executable reference. Its YAML normalization, loader,
-capture, importers, search, shell, and plugins establish the comparison
-behavior. Current machine-output exceptions remain documented on the command
-pages.
+The [inspection shell](../../cli/shell/) runs in the same Python environment.
+Optional interactive backends need their corresponding packages installed.
 
-These observations are a dated local research snapshot, not a support guarantee
-for a published artifact. Read the port's [builder
-topics](../../internals/topics/) and [API](../) for the actual
-library interface. Use the page's language switcher to compare the same topic
-across ports.
+## Output and errors
 
-## Shared gaps
+Machine formats are command-specific. Read [output](../output/) and
+[exit codes](../exit-codes/) for empty output and status exceptions before
+using tmuxp in automation.
 
-Full parity needs document discovery and conversion, schema normalization,
-load/attach/append policy, capture, search, editor execution, diagnostics, and
-Python shell/plugin compatibility. Accepting YAML without rejecting unknown keys
-can silently lose behavior. Passing a parser probe does not establish execution
-parity.
+Capture reads current tmux state; it cannot recover original scripts,
+application state or comments. Review captured commands and directories before
+reloading. Gallery examples may require their named applications or plugins.
 
-Python shell switches and plugin import paths need a Python bridge or an
-explicitly unsupported result. Regex behavior also differs by language;
-identical search flags do not imply Python regular-expression semantics. See
-[shell](../../cli/shell/), [search](../../cli/search/), and
-[hooks](../../configuration/hooks/).
+Use [builder internals](../../internals/) for programmatic construction and
+extension development.
 
-## Optional format separator
-
-Python libtmux exposes `LIBTMUX_TMUX_FORMAT_SEPARATOR` in its format collector.
-Native ports use different framing and decoding strategies. This prototype does
-not claim support for the variable in those codecs. A port needs an explicit
-compatible seam and live tests for collisions, empty values, Unicode, and line
-breaks before accepting the setting.
-
-## Reading examples
-
-The [gallery](../../examples/gallery/) contains the upstream fixture corpus.
-Parsing a fixture and executing its applications are separate checks. Several
-require external programs, remote hosts, project directories, or plugin
-packages. Current native gaps remain visible even when a YAML reader accepts the
-file.
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+[Command source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
diff --git a/site/src/content/docs/ports/rs/examples/capture-pane-output.md b/site/src/content/docs/ports/rs/examples/capture-pane-output.md
new file mode 100644
index 00000000..7c97803f
--- /dev/null
+++ b/site/src/content/docs/ports/rs/examples/capture-pane-output.md
@@ -0,0 +1,117 @@
+---
+port: rs
+route: examples/capture-pane-output
+title: Capture pane output
+description: Run a complete program that captures a pane and waits for a complete output line.
+sidebar:
+  label: Capture pane output
+  group: Examples
+  order: 3
+tableOfContents: true
+---
+
+A pane runs asynchronously: sending a command does not mean its output is
+already on screen. Capture repeatedly until the expected line appears, with a
+deadline so a failed command cannot leave the program waiting forever.
+
+This complete program creates a private tmux server, captures its output, and
+cleans up. Follow the [setup and run instructions](#setup-and-run) below. You need
+tmux and a Unix environment; no existing tmux session is required.
+
+## Read what's on screen
+
+The program sends `printf` with a leading newline, then waits for the complete
+line `libtmux capture ready`. The newline keeps a late shell prompt off that
+line. Matching the whole line avoids mistaking the echoed command for its output.
+
+```rust title="main.rs"
+use std::error::Error;
+use std::time::Duration;
+
+use libtmux::{NewSessionOptions, Server};
+use tokio::time::{sleep, timeout};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let directory = tempfile::tempdir()?;
+    let server = Server::builder()
+        .socket_path(directory.path().join("tmux.sock"))
+        .config_file("/dev/null")
+        .build()?;
+
+    let captured = timeout(Duration::from_secs(5), async {
+        let session = server
+            .new_session(NewSessionOptions::new("capture").command("env ENV=/dev/null sh"))
+            .await?;
+        let panes = session.panes().await?;
+        let pane = panes.first().ok_or("the session has no pane")?;
+        pane.send_line("printf '\\nlibtmux capture ready\\n'").await?;
+        loop {
+            let lines = pane.capture().await?;
+            if let Some(line) = lines
+                .iter()
+                .find(|line| line.as_bytes() == b"libtmux capture ready")
+            {
+                println!("{}", line.to_string_lossy());
+                return Ok::<_, Box<dyn Error>>(());
+            }
+            sleep(Duration::from_millis(20)).await;
+        }
+    })
+    .await;
+
+    let killed = server.kill().await;
+    let closed = server.shutdown().await;
+    captured??;
+    killed?;
+    closed?;
+    Ok(())
+}
+```
+
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
+
+## Wait for output or completion
+
+The program above checks the captured screen for up to five seconds. The short
+pause between checks limits polling; the observed output determines when the loop
+finishes. A tmux capture is a view of the screen and scrollback, so it can miss
+output that has already scrolled away. Use a stream or a completion signal for
+long-running commands when that distinction matters.
+
+[Capturing output](/guides/capturing-output/) covers capture options, while
+[Sending keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site)
+explains why sending and waiting are separate operations.
+
+## Setup and run
+
+Use an empty directory. The commands pin the library
+revision used to verify the program.
+
+Save the program as `src/main.rs` and this file as `Cargo.toml`. Use the
+repository's Rust 1.97.1 toolchain for this pinned revision.
+
+```toml title="Cargo.toml"
+[package]
+name = "capture-example"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+libtmux = { path = "libtmux/crates/libtmux" }
+tempfile = "3.27.0"
+tokio = { version = "1.53.1", features = ["macros", "rt-multi-thread", "time"] }
+```
+
+```console
+$ git clone https://github.com/libtmux/libtmux-rs libtmux &&
+  git -C libtmux checkout d4e08b4eaab62ef4eeedab79b47973ae9a1de310 &&
+  cargo +1.97.1 run
+```
+
+<a id="source-inclusion"></a>
+
+## Where this comes from
+
+This complete program was run against the library revision pinned above.
+The displayed code is checked against the bytes from that run.
diff --git a/site/src/content/docs/ports/rs/workspace/internals/index.md b/site/src/content/docs/ports/rs/workspace/internals/index.md
index 9c98018d..fbdd1f62 100644
--- a/site/src/content/docs/ports/rs/workspace/internals/index.md
+++ b/site/src/content/docs/ports/rs/workspace/internals/index.md
@@ -10,9 +10,9 @@ sidebar:
 tableOfContents: true
 ---
 
-These pages document the in-development workspace builder for contributors
-and applications that call its APIs. For workspace loading from a terminal,
-see [tmuxp](https://tmuxp.git-pull.com/).
+Build and inspect tmux sessions from application code with the workspace
+library. To load files from a terminal, start with the
+[native CLI walkthrough](../guides/installation/).
 
 ## Builder pipeline
 
@@ -31,7 +31,7 @@ reading, the async runtime, command-line handling, and attachment.
 ## Implementation scope
 
 `tmux-workspace` creates a tmux session from a
-[tmuxp](https://tmuxp.git-pull.com)-style YAML description.
+YAML description.
 The crate uses the public libtmux API and returns a typed session handle. A
 separate `freeze` operation records an existing session as workspace data.
 
@@ -45,9 +45,7 @@ freezing are asynchronous and require a running Tokio runtime and tmux on the
 host. Pin a prerelease explicitly; a stable-only Cargo requirement does not
 select an alpha release.
 
-The format covers a subset of tmuxp. Unknown keys are recorded in
-`unsupported_keys` by
-the parser. Review those lists before assuming a Python workspace's setup
-hooks or configuration have taken effect.
+The parser records unknown keys in `unsupported_keys`. Review those lists
+before building: an unrecognized field does not configure the created session.
 
 [Crate documentation](https://github.com/libtmux/libtmux-rs/blob/9331cdf556ea7a1f2589e9c3e6cece6ccdc7765c/crates/tmux-workspace/README.md)
diff --git a/site/src/content/docs/ports/rs/workspace/internals/topics.md b/site/src/content/docs/ports/rs/workspace/internals/topics.md
index 853c7d35..b22b1cf1 100644
--- a/site/src/content/docs/ports/rs/workspace/internals/topics.md
+++ b/site/src/content/docs/ports/rs/workspace/internals/topics.md
@@ -16,16 +16,14 @@ server.
 
 ## Configuration
 
-`Workspace::from_yaml` accepts [tmuxp](https://tmuxp.git-pull.com)-style
-session, window, and pane data. The configuration supports working directories,
+`Workspace::from_yaml` accepts session, window and pane data. The configuration supports working directories,
 commands, environment variables, options, focus, and layouts. Unknown keys are
 listed in `unsupported_keys` and ignored.
-That behavior differs from a strict parser: successful parsing does not prove
-that every field in a larger tmuxp file was applied.
+Review `unsupported_keys` before building so an unrecognized field does not
+leave the session missing an expected setting.
 
 A pane's working directory overrides its window's directory, which overrides
-the workspace's directory. The parser and builder own the supported shape;
-Python plugins are not loaded by the crate.
+the workspace's directory. The parser and builder own the supported configuration fields.
 
 ## Preview and execution
 
diff --git a/site/src/content/docs/ports/rs/workspace/reference/compatibility.md b/site/src/content/docs/ports/rs/workspace/reference/compatibility.md
index f3e2f8ae..aa3d9033 100644
--- a/site/src/content/docs/ports/rs/workspace/reference/compatibility.md
+++ b/site/src/content/docs/ports/rs/workspace/reference/compatibility.md
@@ -1,143 +1,48 @@
 ---
-title: "tmuxp compatibility and port status"
-description: "Current local CLI capabilities, remaining gaps, and the historical builder audit."
+title: Runtime and configuration support
+description: Runtime requirements and configuration boundaries for the Rust workspace command.
 port: rs
 product: workspace
 sidebar:
-  label: "tmuxp compatibility and port status"
+  label: Runtime and configuration support
   group: "Reference"
   order: 30
 tableOfContents: true
 ---
 
-**Local implementation, unpublished.** The Rust `tmux-workspace` CLI
-is available in the `workspace-cli` source worktree. Its command and
-configuration coverage remains partial. See [installation](../../guides/installation/)
-for local setup; installing a published library does not establish availability
-of this CLI.
+`tmux-workspace` is the Rust command for loading and capturing tmux
+workspaces. The [installation guide](../../guides/installation/) builds the
+documented source revision and runs a session on a private socket. The
+walkthroughs require tmux 3.2a or newer.
 
-Compatibility targets useful tmuxp 1.74.0 commands and workspace workflows, with
-native validation, execution and output conventions. Matching command names does
-not promise identical runtime behavior or Python semantics.
+## Runtime and execution
 
-## This port
+Build with the toolchain selected by the repository's `rust-toolchain.toml`.
+The executable provides native loading, capture, discovery, search, conversion,
+import and editing. `--generate` exports its command metadata, manual and
+completion scripts.
 
-The optional CLI feature provides native load, capture, discovery, search,
-conversion, both importers, editor execution and diagnostics. Loading can create
-or reuse a session and append windows. The normalizer handles pane and command
-shorthand, directories, environment, shells, layouts, indexes, focus, options,
-before-script execution and pane-readiness policies. Configuration and failure
-handling still need the broader validation listed below.
+Plugins, custom builders and `shell` use an optional tmuxp 1.74 runtime selected
+by `TMUX_WORKSPACE_PYTHON`. Scripted and extension loads require supported
+child-process observation; targets without it refuse those operations before
+changing tmux.
 
-`--append` validates the inherited `TMUX` and `TMUX_PANE` context before Python
-lookup or load events. Every input retains the same borrowed session. Native
-execution checks its daemon identity before each input and after `before_script`.
-Missing or replaced targets are rejected; separate tmux calls are not atomic.
+The workspace crate also exposes a library. Its unsupported-field handling and
+modeled builder features differ from the CLI; use the library reference for
+application code.
 
-The CLI rejects `-8` and `--88-colors` before reading workspace files or checking
-Python. tmux 3.2a and newer do not support 88-color mode; omit the flag or use
-`-2` for 256 colors.
+## Configuration and failure handling
 
-Every command accepts `--json` and `--ndjson`, with NDJSON taking precedence.
-Load emits operation records; captured child output remains separate from native
-result data. Human output includes semantic colors. Conversion retains document
-fields that native execution does not use. Capture records live workspace shape
-and warns about information it cannot reconstruct. Search uses Rust's native
-`fancy_regex` engine, not Python `re`.
+Read [configuration](../../configuration/) for the CLI's fields. Unsupported
+execution fields fail visibly; generic [conversion](../../cli/convert/)
+preserves document values without proving that they can be executed.
 
-Human load validates terminal access and the invoking tmux client before
-mutation. Progress supports templates and bounded script lines; machine output
-disables its terminal display. Human tree/full listing escapes control bytes
-in labels and paths. Output failures preserve acknowledged load results when
-the remaining diagnostic stream is writable.
+Use [machine output](../output/) for automation and check both the process
+status and any retained effects. Capture reads live tmux state; it cannot
+recover original command arguments, scripts, comments or application state.
 
-SIGINT and SIGTERM return status 130 with completed inputs and acknowledged
-effects. Cancellation does not roll those changes back. After mutation begins,
-`outcome_unknown` discloses possible effects without receipts. Before-script
-output enters retained state only when the script finishes, so interruption
-can omit unfinished capture.
+[Examples](../../examples/gallery/) provide complete starter documents. Their
+pane commands can need additional applications and directories when adapted.
+Use [library internals](../../internals/) for the programmatic builder.
 
-On supported targets, human bootstrap scripts temporarily own the foreground
-terminal while retaining stdin. Exit, failure and cancellation restore the
-original foreground group and terminal settings. Captured child groups stop
-on cancellation; descendants that leave the owned group are outside cleanup.
-See the [native lifecycle contract](https://github.com/libtmux/libtmux-rs/blob/d746b9a5506bb3a9f42cb1401f4568a5d08e77b7/crates/tmux-workspace/README.md#cli-cancellation).
-
-Native load supports [filtered file logging](../output/#native-rust-logging).
-Invalid log destinations are refused before tmux or Python runs.
-
-Python shell, plugin and custom-builder behavior uses an explicit bridge that
-checks tmuxp 1.74.0. Extension loading reports that Python owns those hooks; it
-is not native Rust plugin execution. The bridge preserves a borrowed append
-session when the Python bootstrap fails. It validates the retained target before
-extension imports and again before building. Extensions can still change live
-state through their own code. Editor and interactive Python services
-can use a controlling terminal while machine results remain on stdout.
-
-The command graph can generate reference metadata, manuals and shell completion.
-Local installation and matched tmuxp measurements have exercised specific
-detached-load and capture fixtures on tmux 3.2a and a newer release; they do not
-establish the final CLI's complete lifecycle or package contract.
-
-The local source reference is crates/tmux-workspace/src/cli/. Use the native
-executable's `--help` for the options implemented in that checkout.
-
-### Remaining gaps
-
-- Broader platform lifecycle and output-backpressure coverage remains open.
-  Unix targets whose current bindings lack the safe non-reaping child observer
-  reject scripted and Python-extension loads before target lookup or mutation.
-  This includes Cygwin, NetBSD and OpenBSD; nonscripted operations retain their
-  existing support.
-- Discovery precedence, individual pane-command search, YAML merges, extension
-  fields and command/directory expansion need broader corpus checks.
-- Packaged generated references and broader feature/MSRV/platform coverage
-  remain open.
-
-## Historical builder audit
-
-Audit date: 2026-09-09. [Native source snapshot](https://github.com/libtmux/libtmux-rs/tree/4a9afac1d82d9a6a9af16099e7b846e69f0e6388).
-The following results describe that original library revision, before the local
-CLI implementation. They are historical evidence, not its current capability
-list or a support guarantee for a published artifact.
-
-The library parsed 17 of the 23 upstream YAML examples in the original audit.
-Command shorthand could leave Enter disabled, implicit and explicit window
-indexes could collide, and split panes did not inherit `window_shell` as
-required. Serialization and capture could discard unsupported fields. The source
-snapshot had no native CLI.
-
-At that baseline, `tmux-workspace` parsed a configuration subset and recorded
-unknown keys in `unsupported_keys` without executing them. Its builder created a
-new session, and failure after creation could leave partial state. These are
-historical library results, separate from the current CLI normalization and
-process services.
-
-Read the port's [builder topics](../../internals/topics/) and
-[API](../) for its library interface. Use the language switcher
-to compare the same topic across ports; each port has its own coverage limits.
-
-## Shared gaps
-
-Parser acceptance does not prove execution support. Native regex engines and
-Python plugin runtimes have different contracts; identical flags alone do not
-establish compatibility. See [shell](../../cli/shell/),
-[search](../../cli/search/) and [hooks](../../configuration/hooks/), and apply
-this port's current limitations above when reading those reference pages.
-
-## Optional format separator
-
-Python libtmux exposes `LIBTMUX_TMUX_FORMAT_SEPARATOR` in its format collector.
-This native CLI does not claim that setting as a supported codec control. Its
-framing and decoding need their own compatible seam and collision, empty value,
-Unicode and line-break checks before accepting such a setting.
-
-## Reading examples
-
-The [gallery](../../examples/gallery/) contains the upstream fixture corpus.
-Parsing a fixture and executing its applications are separate checks. Several
-require external programs, remote hosts, project directories or plugin
-packages. A successful YAML read does not establish those dependencies or the
-complete workspace behavior.
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+[CLI source](https://github.com/libtmux/libtmux-rs/blob/e9be0b6f6d22cd2eb79b0ec08964f82e717e5fe4/crates/tmux-workspace/docs/cli.md).
diff --git a/site/src/content/docs/ports/swift/examples/capture-pane-output.md b/site/src/content/docs/ports/swift/examples/capture-pane-output.md
new file mode 100644
index 00000000..e142cb7b
--- /dev/null
+++ b/site/src/content/docs/ports/swift/examples/capture-pane-output.md
@@ -0,0 +1,151 @@
+---
+port: swift
+route: examples/capture-pane-output
+title: Capture pane output
+description: Run a complete program that captures a pane and waits for a complete output line.
+sidebar:
+  label: Capture pane output
+  group: Examples
+  order: 3
+tableOfContents: true
+---
+
+A pane runs asynchronously: sending a command does not mean its output is
+already on screen. Capture repeatedly until the expected line appears, with a
+deadline so a failed command cannot leave the program waiting forever.
+
+This complete program creates a private tmux server, captures its output, and
+cleans up. Follow the [setup and run instructions](#setup-and-run) below. You need
+tmux and a Unix environment; no existing tmux session is required.
+
+## Read what's on screen
+
+The program sends `printf` with a leading newline, then waits for the complete
+line `libtmux capture ready`. The newline keeps a late shell prompt off that
+line. Matching the whole line avoids mistaking the echoed command for its output.
+
+```swift title="Capture.swift"
+import Foundation
+import LibTmux
+
+enum CaptureError: Error {
+    case failed(String)
+}
+
+@main
+struct Capture {
+    static func main() async throws {
+        let directory = URL(fileURLWithPath: "/tmp/libtmux-swift-dev")
+            .appendingPathComponent(UUID().uuidString)
+        try FileManager.default.createDirectory(
+            at: directory, withIntermediateDirectories: true,
+            attributes: [.posixPermissions: 0o700]
+        )
+        let server = try Server(
+            socketPath: directory.appendingPathComponent("tmux.sock").path,
+            configurationFile: "/dev/null"
+        )
+        var started = false
+        var failure: (any Error)?
+        do {
+            let created = try await server.run(TmuxCommand(
+                "new-session",
+                ["-d", "-s", "capture", "env -u ENV -u BASH_ENV /bin/sh"]
+            ))
+            guard created.isSuccess else {
+                throw CaptureError.failed(created.errorText)
+            }
+            started = true
+            guard let pane = try await server.panes().first else {
+                throw CaptureError.failed("The session has no pane")
+            }
+            try await server.run("printf '\\nlibtmux capture ready\\n'", in: pane)
+            let clock = ContinuousClock()
+            let deadline = clock.now.advanced(by: .seconds(5))
+            var captured = false
+            while clock.now < deadline {
+                let lines = try await server.capture(pane)
+                if lines.contains("libtmux capture ready") {
+                    print("libtmux capture ready")
+                    captured = true
+                    break
+                }
+                try await Task.sleep(for: .milliseconds(25))
+            }
+            guard captured else {
+                throw CaptureError.failed("Output did not arrive within five seconds")
+            }
+        } catch {
+            failure = error
+        }
+
+        var cleanupFailed = false
+        if started {
+            do { try await server.killServer() }
+            catch {
+                FileHandle.standardError.write(Data("Stop tmux: \(error)\n".utf8))
+                cleanupFailed = true
+            }
+        }
+        do { try FileManager.default.removeItem(at: directory) }
+        catch {
+            FileHandle.standardError.write(Data("Remove socket: \(error)\n".utf8))
+            cleanupFailed = true
+        }
+        if let failure { throw failure }
+        if cleanupFailed { throw CaptureError.failed("Cleanup failed; see diagnostics") }
+    }
+}
+```
+
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
+
+## Wait for output or completion
+
+The program above checks the captured screen for up to five seconds. The short
+pause between checks limits polling; the observed output determines when the loop
+finishes. A tmux capture is a view of the screen and scrollback, so it can miss
+output that has already scrolled away. Use a stream or a completion signal for
+long-running commands when that distinction matters.
+
+[Capturing output](/guides/capturing-output/) covers capture options, while
+[Sending keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site)
+explains why sending and waiting are separate operations.
+
+## Setup and run
+
+Use an empty directory. The commands pin the library
+revision used to verify the program.
+
+Save the program as `Sources/Capture/Capture.swift` and this file as
+`Package.swift`. Use Swift 6.2 or newer.
+
+```swift title="Package.swift"
+// swift-tools-version: 6.2
+import PackageDescription
+
+let package = Package(
+    name: "CaptureExample",
+    platforms: [.macOS(.v13)],
+    dependencies: [.package(path: "libtmux-source")],
+    targets: [
+        .executableTarget(
+            name: "Capture",
+            dependencies: [.product(name: "LibTmux", package: "libtmux-source")]
+        ),
+    ]
+)
+```
+
+```console
+$ git clone https://github.com/libtmux/libtmux-swift libtmux-source &&
+  git -C libtmux-source checkout 254f8b2be7eb60cacc3ffcb3ea8e456784f582df &&
+  swift run --jobs 2 Capture
+```
+
+<a id="source-inclusion"></a>
+
+## Where this comes from
+
+This complete program was run against the library revision pinned above.
+The displayed code is checked against the bytes from that run.
diff --git a/site/src/content/docs/ports/swift/mcp/examples.md b/site/src/content/docs/ports/swift/mcp/examples.md
index c1161486..81b94e0c 100644
--- a/site/src/content/docs/ports/swift/mcp/examples.md
+++ b/site/src/content/docs/ports/swift/mcp/examples.md
@@ -1,69 +1,170 @@
 ---
 title: Swift MCP examples
-description: List sessions through the Swift MCP server and inspect implementation examples.
+description: Call an embedded Swift MCP tool against a private tmux server.
 port: swift
 product: mcp
 sidebar:
   label: Examples
   order: 3
+tableOfContents: true
 ---
 
-Connect the server using the [setup guide](../guides/), then call
-[`list_sessions`](../tools/list_sessions/) from your MCP client.
+Embed the Swift MCP tool surface, expose only `list_sessions`, and check its
+structured result against a private tmux session. The program calls the same
+tool implementation used by the stdio server. For an external MCP client,
+use the [connection guide](../guides/).
 
-## List sessions
+## Prepare the project
 
-This is the `params` object for an MCP `tools/call` request. Send it
-through the connected client:
+Use Swift 6.2.4, Git, and tmux 3.2a or newer on Linux. Create an empty project
+and the executable's source directory:
 
-```json
-{
-  "name": "list_sessions",
-  "arguments": {}
-}
+```console
+$ mkdir swift-mcp-example && cd swift-mcp-example && \
+  mkdir -p Sources/MCPExample
+```
+
+Fetch the library revision used by this example:
+
+```console
+$ git init libtmux-source && \
+  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \
+  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
+  git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
-Use the returned session IDs when choosing a window or pane. The
-[tool reference](../tools/list_sessions/) describes this port's result
-and optional arguments.
+Save the following package manifest at the project root:
+
+```swift title="Package.swift"
+// swift-tools-version: 6.2
+import PackageDescription
+
+let package = Package(
+    name: "MCPExample",
+    platforms: [.macOS(.v13)],
+    dependencies: [.package(path: "libtmux-source")],
+    targets: [
+        .executableTarget(
+            name: "MCPExample",
+            dependencies: [
+                .product(name: "LibTmux", package: "libtmux-source"),
+                .product(name: "LibTmuxMCP", package: "libtmux-source"),
+            ]
+        ),
+    ]
+)
+```
 
-## Internals
+<a id="list-sessions"></a>
+<a id="internals"></a>
+<a id="embed-the-tool-surface"></a>
 
-The following examples are for applications that embed or extend the server.
-Installing and connecting an MCP client does not require this code.
+## Run the complete program
 
-The Swift example package uses the public
-[`LibTmuxMCP`](https://github.com/libtmux/libtmux-swift/blob/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Package.swift)
-product directly.
-It demonstrates the default readonly surface and an exact typed
-selection without launching a stdio subprocess.
+Save this file in the source directory created above. Its private socket is
+checked during cleanup even when startup fails. Cleanup failures preserve the
+original error and report the retained directory.
 
-### Embed the tool surface
+```swift title="Sources/MCPExample/MCPExample.swift"
+import Foundation
+import LibTmux
+import LibTmuxMCP
 
-```swift file="Examples/Sources/ExampleCode/MCPEmbedding.swift"
-```
+struct ExampleFailure: Error, CustomStringConvertible {
+    let description: String
+}
+
+func withPrivateTmux(
+    _ body: @Sendable (Server) async throws -> Void
+) async throws {
+    let directory = URL(fileURLWithPath: "/tmp")
+        .appendingPathComponent("libtmux-swift-example-\(UUID().uuidString)")
+    let server = try Server(
+        socketPath: directory.appendingPathComponent("s").path,
+        configurationFile: "/dev/null"
+    )
+    try FileManager.default.createDirectory(
+        at: directory, withIntermediateDirectories: false,
+        attributes: [.posixPermissions: 0o700]
+    )
+    var failures: [String] = []
+    do { try await body(server) }
+    catch { failures.append("Operation: \(error)") }
+    do {
+        let files = try FileManager.default.contentsOfDirectory(
+            atPath: directory.path
+        )
+        if files.contains("s") { try await server.killServer() }
+        try FileManager.default.removeItem(at: directory)
+    } catch {
+        failures.append("Cleanup at \(directory.path): \(error)")
+    }
+    if !failures.isEmpty {
+        throw ExampleFailure(description: failures.joined(separator: "\n"))
+    }
+}
 
-The first function lists visible definitions and calls `list_panes`.
-The caller supplies the existing `Server` and retains its lifetime.
-The second function starts with no toolsets and includes only its named
-operations. It does not include future tools automatically.
+@main
+struct MCPExample {
+    static func main() async throws {
+        try await withPrivateTmux { server in
+            let started = try await server.run([
+                TmuxCommand("set-option", ["-g", "default-shell", "/bin/sh"]),
+                TmuxCommand("set-environment", ["-g", "ENV", ""]),
+                TmuxCommand("set-environment", ["-g", "BASH_ENV", ""]),
+                TmuxCommand("new-session", [
+                    "-d", "-s", "mcp-example", "exec /bin/cat",
+                ]),
+            ])
+            guard started.isSuccess else {
+                throw ExampleFailure(description: started.errorText)
+            }
+            let tools = TmuxTools(
+                server: server,
+                authority: ToolAuthority(
+                    toolsets: [], includedTools: ["list_sessions"]
+                ),
+                caller: nil
+            )
+            let names = tools.visibleDefinitions.map(\.name)
+            guard names == ["list_sessions"] else {
+                throw ExampleFailure(description: "Unexpected tool selection")
+            }
+            let result = try await tools.call(ToolCall(name: "list_sessions"))
+            guard let sessions = result.structured["sessions"]?.arrayValue,
+                sessions.count == 1,
+                sessions[0]["name"]?.stringValue == "mcp-example"
+            else {
+                throw ExampleFailure(description: "Unexpected session result")
+            }
+            print("tools: \(names.joined(separator: ", "))")
+            print("sessions: mcp-example")
+        }
+    }
+}
+```
 
-### Run its tests
+<a id="run-its-tests"></a>
 
-From the Swift repository with its toolchain and tmux installed:
+Build and run the executable:
 
 ```console
-$ swift test \
-    --package-path Examples \
-    --filter MCPEmbeddingTests
+$ swift run --jobs 2 MCPExample
+```
+
+Expected output:
+
+```text
+tools: list_sessions
+sessions: mcp-example
 ```
 
-The [example tests](https://github.com/libtmux/libtmux-swift/blob/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Examples/Tests/ExampleTests/MCPEmbeddingTests.swift)
-use a tmux fixture to verify the pane count and exact offered names.
-Rendering the source does not run that test.
+`ToolAuthority` starts with no toolsets and includes only `list_sessions`.
+`caller: nil` avoids importing an ambient tmux pane identity. The explicitly
+configured server selects the private socket.
 
-The [example source](https://github.com/libtmux/libtmux-swift/blob/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Examples/Sources/ExampleCode/MCPEmbedding.swift)
-is also the basis for the library's embedding documentation.
+A thrown `ToolError` reports a failed invocation. The successful result carries
+structured session data; retain the returned session IDs for later operations.
+The [tool reference](../tools/list_sessions/) describes the result schema.
 
-Use [Workspace builder examples](../../workspace/internals/examples/) for direct
-workspace construction; the MCP catalog has no workspace-file operation.
+[Library source](https://github.com/libtmux/libtmux-swift/tree/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Sources/LibTmuxMCP).
diff --git a/site/src/content/docs/ports/swift/mcp/guides.md b/site/src/content/docs/ports/swift/mcp/guides.md
index b8e18e63..72c7a416 100644
--- a/site/src/content/docs/ports/swift/mcp/guides.md
+++ b/site/src/content/docs/ports/swift/mcp/guides.md
@@ -1,6 +1,6 @@
 ---
 title: Connect a Swift MCP client
-description: Build libtmux-mcp and select its tmux endpoint and tool authority through environment variables.
+description: Build the Swift MCP executable and connect it to a private tmux server.
 port: swift
 product: mcp
 sidebar:
@@ -8,61 +8,105 @@ sidebar:
   order: 2
 ---
 
-Build the Swift executable and have the MCP client launch it.
-Use the package's supported Swift toolchain and make tmux available to
-the client process.
+Build the Swift executable, then let your MCP client launch the script below.
+The script owns a private tmux server and exposes only `list_sessions`. It stops
+tmux when the MCP process exits; it does not require an existing tmux session.
 
-## Build and launch
+<a id="build-and-launch"></a>
 
-From the Swift repository:
+## Build the executable
+
+Use Swift 6.2.4, Git, and tmux 3.2a or newer on Linux. Create an empty directory
+for the launcher and source checkout:
 
 ```console
-$ swift build --product libtmux-mcp
+$ mkdir swift-mcp-client && cd swift-mcp-client
 ```
 
-The debug executable is written under `.build/debug`.
-Run an inspection surface on a named socket:
+Fetch the library revision and build its stdio server:
 
 ```console
-$ LIBTMUX_SOCKET=docs-agent LIBTMUX_TOOLSETS=inspect \
-    .build/debug/libtmux-mcp
+$ git init libtmux-source && \
+  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \
+  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
+  git -C libtmux-source checkout --detach FETCH_HEAD && \
+  swift build --package-path libtmux-source --product libtmux-mcp --jobs 2
 ```
 
-It waits for MCP messages. The executable accepts no flags; configure
-its endpoint through the environment.
+Keep the build directory: the executable uses its adjacent resource bundle.
+
+## Save the launcher
+
+Save the following file alongside the source checkout. The trap preserves a
+failed-stop socket for inspection and reports cleanup errors on stderr.
+
+```sh title="run-mcp.sh"
+#!/bin/sh
+set -eu
+unset TMUX TMUX_PANE LIBTMUX_SOCKET
+project=$(CDPATH= cd -P "$(dirname "$0")" && pwd)
+directory=$(mktemp -d /tmp/libtmux-swift-mcp.XXXXXXXX)
+cleanup() {
+    status=$?
+    trap - 0 HUP INT TERM
+    if [ -S "$directory/s" ]; then
+        if ! tmux -S "$directory/s" kill-server; then
+            printf 'Cannot stop private server; inspect %s\n' "$directory" >&2
+            exit 1
+        fi
+    fi
+    if ! rm -f "$directory/s" || ! rmdir "$directory"; then
+        printf 'Cannot remove private directory: %s\n' "$directory" >&2
+        exit 1
+    fi
+    exit "$status"
+}
+trap cleanup 0
+trap 'exit 129' HUP
+trap 'exit 130' INT
+trap 'exit 143' TERM
+tmux -S "$directory/s" -f /dev/null \
+    set-option -g default-shell /bin/sh \; \
+    set-environment -g ENV '' \; \
+    set-environment -g BASH_ENV '' \; \
+    new-session -d -s mcp-example 'exec /bin/cat'
+LIBTMUX_SOCKET_PATH="$directory/s" \
+LIBTMUX_TMUX_BIN=tmux LIBTMUX_TMUX_CONFIG=/dev/null \
+LIBTMUX_TOOLSETS= LIBTMUX_TOOLS=list_sessions LIBTMUX_EXCLUDE_TOOLS= \
+    "$project/libtmux-source/.build/debug/libtmux-mcp"
+```
 
-## Connect a client
+Run it directly to check startup:
 
-If the executable is on the client's `PATH`, use this
-`mcpServers` entry. Otherwise set `command` to its actual built location.
-
-```json
-{
-  "mcpServers": {
-    "tmux-swift": {
-      "command": "libtmux-mcp",
-      "env": {
-        "LIBTMUX_SOCKET": "docs-agent",
-        "LIBTMUX_TOOLSETS": "inspect"
-      }
-    }
-  }
-}
+```console
+$ sh run-mcp.sh
 ```
 
-`LIBTMUX_SOCKET_PATH` and `LIBTMUX_SOCKET` are mutually exclusive.
-`LIBTMUX_TMUX_BIN` selects the tmux executable.
+It waits for MCP messages on stdin. Send EOF to close the process and trigger
+cleanup. The executable accepts no flags; its endpoint and tool selection come
+from environment variables.
+
+## Connect a client
+
+Configure the client to run `sh` with the launcher's absolute path as its only
+argument. The client must have tmux on its `PATH`. The launcher finds the build
+relative to its own file, so the client's working directory does not matter.
 
-## Verify and narrow the surface
+<a id="verify-and-narrow-the-surface"></a>
 
-Ask the client to list sessions and read `tmux://capabilities`.
-Retain opaque references from listings for follow-up calls.
+Ask the client to list its tools, then call
+[`list_sessions`](../tools/list_sessions/). The offered surface contains only
+that tool, and its result contains the launcher's `mcp-example` session.
 
-To allow only listing and window creation, set `LIBTMUX_TOOLSETS` to
-an empty string and `LIBTMUX_TOOLS=list_sessions,create_window`.
-Reconnect after changing environment variables.
+An empty `LIBTMUX_TOOLSETS` plus the named `LIBTMUX_TOOLS` selection excludes
+other operations. Reconnect after changing the selection. Invalid selections
+fail startup and write diagnostics to stderr.
 
-Invalid tool selections fail startup; inspect stderr diagnostics. A stale pane reference needs a fresh listing,
-not another spelling of the same raw ID.
+For a server the application already owns, select its absolute socket with
+`LIBTMUX_SOCKET_PATH` or its socket name with `LIBTMUX_SOCKET`; these settings
+are mutually exclusive. `LIBTMUX_TMUX_BIN` selects a specific tmux executable.
 
-[Executable contract](https://github.com/libtmux/libtmux-swift/blob/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Sources/libtmux-mcp/README.md).
+The [complete embedded example](../examples/) calls the Swift tool surface
+inside a consumer program. The
+[executable contract](https://github.com/libtmux/libtmux-swift/blob/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Sources/libtmux-mcp/README.md)
+describes its environment and protocol behavior.
diff --git a/site/src/content/docs/ports/swift/workspace/internals/examples.md b/site/src/content/docs/ports/swift/workspace/internals/examples.md
index 36a11da7..e7f7a7bc 100644
--- a/site/src/content/docs/ports/swift/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/swift/workspace/internals/examples.md
@@ -1,6 +1,6 @@
 ---
-title: "Swift workspace builder examples"
-description: "Internal examples for building and inspecting workspaces through the Swift API."
+title: Swift workspace builder examples
+description: Build and inspect a private workspace with a complete Swift program.
 port: swift
 product: workspace
 sidebar:
@@ -10,38 +10,160 @@ sidebar:
 tableOfContents: true
 ---
 
-The port's [`ExampleCode`](https://github.com/libtmux/libtmux-swift/blob/f02a4668570e1cc5198c941413750e021f42c214/Examples/Package.swift) package contains functions for describing a workspace
-in Swift, building it, and reading JSON or YAML. Its tests compile and call
-those functions.
+Build two windows with two editor panes, inspect a fresh snapshot, then stop
+the private tmux server. The example uses `/bin/cat` to keep its panes open
+without reading shell startup files or requiring another application.
 
-## Describe and build
+## Prepare the project
 
-The example's YAML reader requires the dependency's `YAMLWorkspaces` trait.
-That trait enables the API inside the dependency; it does not define the same
-compilation condition in a consumer package.
+Use Swift 6.2.4, Git, and tmux 3.2a or newer on Linux. Create an empty project
+and the executable's source directory:
 
-```swift file="Examples/Sources/ExampleCode/Workspaces.swift"
+```console
+$ mkdir swift-workspace-example && cd swift-workspace-example && \
+  mkdir -p Sources/WorkspaceExample
+```
+
+Fetch the library revision used by this example:
+
+```console
+$ git init libtmux-source && \
+  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \
+  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
+  git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
-The log pane expects a log file at the configured path. Change that command
-to match the application before using the description as a launcher. The
-returned session is a captured value; request a fresh server snapshot to
-inspect membership after all windows have been created.
+Save the following package manifest at the project root:
+
+```swift title="Package.swift"
+// swift-tools-version: 6.2
+import PackageDescription
+
+let package = Package(
+    name: "WorkspaceExample",
+    platforms: [.macOS(.v13)],
+    dependencies: [.package(path: "libtmux-source")],
+    targets: [
+        .executableTarget(
+            name: "WorkspaceExample",
+            dependencies: [
+                .product(name: "LibTmux", package: "libtmux-source"),
+                .product(name: "TmuxWorkspace", package: "libtmux-source"),
+            ]
+        ),
+    ]
+)
+```
+
+<a id="describe-and-build"></a>
+
+## Run the complete program
 
-The [guide](../guides/) provides an isolated executable and cleanup. These
-helper functions accept a caller-owned server and keep the workspace running
-for that caller to use.
+Save this file in the source directory created above. Its private socket is
+checked during cleanup even when startup fails. Cleanup failures preserve the
+original error and report the retained directory.
 
-## Verification
+```swift title="Sources/WorkspaceExample/WorkspaceExample.swift"
+import Foundation
+import LibTmux
+import TmuxWorkspace
 
-From a prepared source checkout, run the example package:
+struct ExampleFailure: Error, CustomStringConvertible {
+    let description: String
+}
+
+func withPrivateTmux(
+    _ body: @Sendable (Server) async throws -> Void
+) async throws {
+    let directory = URL(fileURLWithPath: "/tmp")
+        .appendingPathComponent("libtmux-swift-example-\(UUID().uuidString)")
+    let server = try Server(
+        socketPath: directory.appendingPathComponent("s").path,
+        configurationFile: "/dev/null"
+    )
+    try FileManager.default.createDirectory(
+        at: directory, withIntermediateDirectories: false,
+        attributes: [.posixPermissions: 0o700]
+    )
+    var failures: [String] = []
+    do { try await body(server) }
+    catch { failures.append("Operation: \(error)") }
+    do {
+        let files = try FileManager.default.contentsOfDirectory(
+            atPath: directory.path
+        )
+        if files.contains("s") { try await server.killServer() }
+        try FileManager.default.removeItem(at: directory)
+    } catch {
+        failures.append("Cleanup at \(directory.path): \(error)")
+    }
+    if !failures.isEmpty {
+        throw ExampleFailure(description: failures.joined(separator: "\n"))
+    }
+}
+
+@main
+struct WorkspaceExample {
+    static func main() async throws {
+        try await withPrivateTmux { server in
+            let started = try await server.run([
+                TmuxCommand("set-option", ["-g", "default-shell", "/bin/sh"]),
+                TmuxCommand("set-option", ["-g", "default-command", "exec /bin/cat"]),
+                TmuxCommand("set-environment", ["-g", "ENV", ""]),
+                TmuxCommand("set-environment", ["-g", "BASH_ENV", ""]),
+                TmuxCommand("new-session", ["-d", "-s", "bootstrap"]),
+            ])
+            guard started.isSuccess else {
+                throw ExampleFailure(description: started.errorText)
+            }
+            let workspace = Workspace(
+                sessionName: "workspace-example",
+                windows: [
+                    WindowPlan(
+                        windowName: "editor", layout: "even-horizontal",
+                        panes: [PanePlan(), PanePlan()]
+                    ),
+                    WindowPlan(windowName: "logs", panes: [PanePlan()]),
+                ]
+            )
+            let session = try await WorkspaceBuilder.build(workspace, on: server)
+            let snapshot = try await server.snapshot()
+            let windows = snapshot.windows(of: session)
+            guard windows.count == 2,
+                let editor = windows.first(where: { $0.name == "editor" }),
+                snapshot.panes(of: editor).count == 2
+            else {
+                throw ExampleFailure(description: "Unexpected workspace layout")
+            }
+            print("built: \(windows.count) windows")
+            print("editor: \(snapshot.panes(of: editor).count) panes")
+        }
+    }
+}
+```
+
+<a id="verification"></a>
+
+Build and run the executable:
 
 ```console
-$ swift test --package-path Examples
+$ swift run --jobs 2 WorkspaceExample
 ```
 
-The port also checks correspondence between these source functions and its
-README examples. Source inclusion in this page keeps the excerpt current;
-it does not run the Swift tests during site rendering.
+Expected output:
+
+```text
+built: 2 windows
+editor: 2 panes
+```
+
+The bootstrap session keeps tmux alive while the builder checks for an
+existing session. The program sets its default command before creating the
+workspace. A fresh snapshot verifies the completed layout: the value returned
+when its first session is created does not include later window additions.
+
+Describe panes with Swift values or decode a configuration with
+`Workspace.decode(json:)`. The [guide](../guides/) explains ownership,
+configuration input and failed-build cleanup.
 
-[Example source](https://github.com/libtmux/libtmux-swift/blob/f02a4668570e1cc5198c941413750e021f42c214/Examples/Sources/ExampleCode/Workspaces.swift)
+[Library source](https://github.com/libtmux/libtmux-swift/tree/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Sources/TmuxWorkspace).
diff --git a/site/src/content/docs/ports/swift/workspace/internals/guides.md b/site/src/content/docs/ports/swift/workspace/internals/guides.md
index 77369fe8..4986b755 100644
--- a/site/src/content/docs/ports/swift/workspace/internals/guides.md
+++ b/site/src/content/docs/ports/swift/workspace/internals/guides.md
@@ -1,6 +1,6 @@
 ---
-title: "Use the Swift workspace builder"
-description: "Use the in-development Swift workspace builder from application code."
+title: Use the Swift workspace builder
+description: Build a workspace, inspect its current layout, and choose its lifetime.
 port: swift
 product: workspace
 sidebar:
@@ -10,76 +10,59 @@ sidebar:
 tableOfContents: true
 ---
 
-Add `TmuxWorkspace` and [`LibTmux`](../../../reference/) to a SwiftPM target. This isolated example
-also uses the public `TmuxFixture` product for server startup and cleanup. The
-following dependency selects the source revision used by these examples:
-
-```swift
-.package(
-    url: "https://github.com/libtmux/libtmux-swift.git",
-    revision: "f02a4668570e1cc5198c941413750e021f42c214"
-)
-```
-
-Add the products to the target's dependencies:
-
-```swift
-.product(name: "LibTmux", package: "libtmux-swift"),
-.product(name: "TmuxWorkspace", package: "libtmux-swift"),
-.product(name: "TmuxFixture", package: "libtmux-swift")
-```
-
-Use the toolchain specified by the port's package manifest and install tmux.
-For YAML input, enable `traits: ["YAMLWorkspaces"]` on the package dependency.
-Swift values and JSON need no trait.
-
-## Build an isolated session
-
-Place this entry point in your executable target. `withTmuxServer` starts a
-private server and removes it after the closure, including when building
-throws. The workspace builder needs a running server for its initial session
-lookup.
-
-```swift
-import LibTmux
-import TmuxFixture
-import TmuxWorkspace
-
-@main
-struct WorkspaceGuide {
-    static func main() async throws {
-        try await withTmuxServer { @Sendable server in
-            let workspace = Workspace(
-                sessionName: "guide",
-                windows: [WindowPlan(
-                    windowName: "editor",
-                    panes: [PanePlan(), PanePlan()]
-                )]
-            )
-            let session = try await WorkspaceBuilder.build(workspace, on: server)
-            print(session.name)
-        }
-    }
-}
-```
-
-Run the executable through SwiftPM:
-
-```console
-$ swift run
-```
+Start with the [complete runnable example](../examples/). It includes the
+SwiftPM manifest, a pinned library dependency, imports, an executable entry
+point, a private tmux server, and cleanup.
 
-## Read configuration
+## Describe the layout
+
+A `Workspace` contains ordered windows. Each `WindowPlan` describes a window's
+name, layout and panes. Its `PanePlan` values describe commands to send and an
+optional starting directory.
+
+The example keeps panes open with `/bin/cat`, so it needs no editor, application
+or log file. Replace those choices with commands appropriate for the workspace
+before using it as an application launcher.
+
+<a id="build-an-isolated-session"></a>
+
+## Build on a running server
+
+`WorkspaceBuilder.build(_:on:)` checks the server's sessions before creating
+its workspace. Start a private bootstrap session first, or pass a running
+server whose lifetime the application owns.
 
-Use `Workspace.decode(json:)` with [`Data`](https://developer.apple.com/documentation/foundation/data), or `Workspace.decode(yaml:)` with a
-string when the YAML trait is enabled. Review unsupported fields before
-moving a Python workspace to this structural subset.
+The builder rejects an existing session with the requested name. After a
+creation failure, it attempts to remove the session it created. Inspect
+`WorkspaceBuilderError.rollbackFailed` when both the operation and its rollback
+fail; that error preserves both causes.
+
+The example's final cleanup stops its whole private server, including the
+bootstrap session. An application that wants the workspace to remain open
+should retain its selected server and stop it when the application is done.
+
+## Inspect the completed layout
+
+Request a fresh `Server.snapshot()` after building. The returned session value
+was captured when the first window was created; it does not become a live view
+as later windows are added.
+
+Use the snapshot's `windows(of:)` and `panes(of:)` methods to inspect membership.
+The complete example asserts the final window and pane counts before printing
+its result.
+
+## Read configuration
 
-The fixture removes the server after inspecting the session name. In an
-application, pass an already running server and retain the result instead. A
-build failure triggers the builder's own cleanup attempt; inspect
-`rollbackFailed` because it reports that the cleanup also failed.
+`Workspace.decode(json:)` reads Foundation `Data`. The accepted model uses
+`session_name`, `windows`, `window_name` and `panes`; unknown keys are ignored.
 
-[Package products and toolchain](https://github.com/libtmux/libtmux-swift/blob/f02a4668570e1cc5198c941413750e021f42c214/Package.swift); [Build contract](https://github.com/libtmux/libtmux-swift/blob/f02a4668570e1cc5198c941413750e021f42c214/Sources/TmuxWorkspace/WorkspaceBuilder.swift).
+YAML input additionally requires the dependency's `YAMLWorkspaces` trait and
+`Workspace.decode(yaml:)`. Enable that trait on the package dependency when
+using YAML. A dependency trait does not define the same compilation condition
+inside a consumer package, so do not wrap the consumer call in an
+`#if YAMLWorkspaces` guard.
 
-[Isolated server fixture](https://github.com/libtmux/libtmux-swift/blob/f02a4668570e1cc5198c941413750e021f42c214/Tests/TmuxFixture/TmuxFixture.swift).
+Swift values and JSON need no YAML dependency. The
+[workspace model](https://github.com/libtmux/libtmux-swift/blob/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Sources/TmuxWorkspace/Workspace.swift)
+and [build contract](https://github.com/libtmux/libtmux-swift/blob/254f8b2be7eb60cacc3ffcb3ea8e456784f582df/Sources/TmuxWorkspace/WorkspaceBuilder.swift)
+describe the accepted fields and failure behavior.
diff --git a/site/src/content/docs/ports/swift/workspace/internals/index.md b/site/src/content/docs/ports/swift/workspace/internals/index.md
index dc5a3580..7020eb7a 100644
--- a/site/src/content/docs/ports/swift/workspace/internals/index.md
+++ b/site/src/content/docs/ports/swift/workspace/internals/index.md
@@ -10,9 +10,9 @@ sidebar:
 tableOfContents: true
 ---
 
-These pages document the in-development workspace builder for contributors
-and applications that call its APIs. For workspace loading from a terminal,
-see [tmuxp](https://tmuxp.git-pull.com/).
+Build and inspect tmux sessions from application code with the workspace
+library. To load files from a terminal, start with the
+[native CLI walkthrough](../guides/installation/).
 
 ## Builder pipeline
 
@@ -31,7 +31,7 @@ handling, and attachment.
 ## Implementation scope
 
 `TmuxWorkspace` builds a tmux session from Swift values or a
-[tmuxp](https://tmuxp.git-pull.com)-style configuration. It is a SwiftPM
+file configuration. It is a SwiftPM
 library product beside the core [`LibTmux`](../../reference/) product.
 
 Swift and JSON descriptions work without a YAML dependency. Enable the
diff --git a/site/src/content/docs/ports/swift/workspace/internals/topics.md b/site/src/content/docs/ports/swift/workspace/internals/topics.md
index 45240971..fc5d9588 100644
--- a/site/src/content/docs/ports/swift/workspace/internals/topics.md
+++ b/site/src/content/docs/ports/swift/workspace/internals/topics.md
@@ -17,11 +17,10 @@ objects to create. Their Codable keys use tmuxp's field spelling.
 
 JSON decoding is always available. YAML decoding is compiled only when the
 package enables `YAMLWorkspaces`, which brings in Yams. Unknown keys are
-ignored by decoding; successful decoding does not establish full tmuxp
-compatibility.
+ignored by decoding. Validate field names against the model before loading
+a configuration.
 
-The model covers names, directories, layouts, and pane commands. Python
-plugins, hooks, and tmuxp's environment runtime are outside that model. A
+The model covers names, directories, layouts and pane commands. A
 window directory overrides the workspace directory. A split pane can provide
 its own directory; the initial pane is created with its window's directory.
 
diff --git a/site/src/content/docs/ports/swift/workspace/reference/compatibility.md b/site/src/content/docs/ports/swift/workspace/reference/compatibility.md
index 35929d2d..7b42f05a 100644
--- a/site/src/content/docs/ports/swift/workspace/reference/compatibility.md
+++ b/site/src/content/docs/ports/swift/workspace/reference/compatibility.md
@@ -1,182 +1,50 @@
 ---
-title: "tmuxp compatibility and port status"
-description: "Current local CLI capabilities, remaining gaps, and the historical builder audit."
+title: Runtime and configuration support
+description: Runtime requirements and configuration boundaries for the Swift workspace command.
 port: swift
 product: workspace
 sidebar:
-  label: "tmuxp compatibility and port status"
+  label: Runtime and configuration support
   group: "Reference"
   order: 30
 tableOfContents: true
 ---
 
-**Local implementation, unpublished.** The Swift `tmux-workspace` CLI
-is available in the `workspace-cli` source worktree. Its command and
-configuration coverage remains partial. See [installation](../../guides/installation/)
-for local setup; installing a published library does not establish availability
-of this CLI.
+`tmux-workspace` is the Swift command for loading and capturing tmux
+workspaces. The [installation guide](../../guides/installation/) builds the
+documented source revision and runs a session on a private socket. The
+walkthroughs require tmux 3.2a or newer.
 
-Compatibility targets useful tmuxp 1.74.0 commands and workspace workflows, with
-native validation, execution and output conventions. Matching command names does
-not promise identical runtime behavior or Python semantics.
+## Runtime and execution
 
-## This port
+Use Swift 6.2. YAML decoding requires the `YAMLWorkspaces` build trait;
+JSON documents work without it. Keep the matching runtime libraries available
+when running a source-built Linux executable.
 
-Native services cover load, append, capture, discovery, search,
-conversion, both importers, editor execution and diagnostics. Loading creates
-sessions or reuses exact names. Append authenticates the inherited server PID,
-selected endpoint and current pane; failure preserves the borrowed session and
-reports new windows and potentially changed settings. A failed new build removes
-only its created session and reports earlier successful workspaces.
+Native services handle loading, capture, discovery, search, conversion, import
+and editing. Search uses ICU regular expressions. Select an explicit endpoint
+with `-S` or `-L` when loading outside tmux.
 
-Loading supports pane shorthand, inherited commands, sequential enter settings,
-history suppression, directories, layouts, indexes, focus, session environment
-and session/window options. Before-scripts run direct argv after session
-creation, from the expanded session directory or invocation directory. All input
-documents are validated before creation, including expanded session names and
-NUL rejection. Unsupported execution keys fail explicitly. Outside tmux, load
-currently requires an explicit `-S` or `-L` endpoint. Append uses new slots and
-ignores configured indexes.
+Set delays on panes. Command mappings support Enter overrides but reject
+per-command timing fields. Plugins and custom workspace builders are
+unsupported. The optional inspection `shell` requires tmuxp 1.74.0 in the
+interpreter selected by `TMUX_WORKSPACE_PYTHON`.
 
-Loading checks layouts across all inputs before setup scripts or topology
-changes. Named layouts accept unique abbreviations supported by the running
-daemon; only a cold endpoint falls back to the selected client's version.
-Serialized layouts have bounded checksum, tree and pane-count validation.
-Tmux remains responsible for geometry correction and pruning.
+The `TmuxWorkspace` library has a separate model and construction API. Consult
+its reference when building sessions from Swift code.
 
-Human load with a foreground terminal attaches to the final workspace. Inside
-tmux, a prompt offers switching, detached loading, appending or cancellation.
-`-y` skips that mode prompt but refuses an ambiguous client selection. All
-inputs are validated before prompting. Redirected and machine calls require
-`-d` or `--append` and never prompt. Detaching or interrupting the attached
-client preserves loaded workspaces and restores terminal settings.
+## Configuration and failure handling
 
-Switching checks the selected server, pane terminal and client's current PID,
-session and globally active pane. A client with independent `active-pane`
-focus on the invoking pane's physical window prevents switching; detached
-and append choices remain available. Independent clients on other windows do
-not block switching. If the selected client gains the flag before handoff,
-the switch fails and the loaded workspace remains.
+Read [configuration](../../configuration/) for the CLI's fields. Unsupported
+execution fields fail visibly; generic [conversion](../../cli/convert/)
+preserves document values without proving that they can be executed.
 
-A tmux client name can be reused after that check; outside
-attachment likewise checks the server before starting the terminal client.
-These checks do not make the separate attachment process atomic with a server
-restart or client replacement.
+Use [machine output](../output/) for automation and check both the process
+status and any retained effects. Capture reads live tmux state; it cannot
+recover original command arguments, scripts, comments or application state.
 
-`load -2` forces 256-color handling in direct and control clients, together with
-any explicit tmux configuration file. Legacy `-8` is recognized but rejected
-before document lookup or backend access; supplying both flags is a usage
-error. Without `-2`, tmux detects color support.
+[Examples](../../examples/gallery/) provide complete starter documents. Their
+pane commands can need additional applications and directories when adapted.
+Use [library internals](../../internals/) for the programmatic builder.
 
-YAML requires the `YAMLWorkspaces` build trait. Conversion preserves extension
-fields, and both importers require an explicit source. Import warns about
-untranslated fields, and rejects unexpanded ERB in a Tmuxinator source, which
-Ruby would have expanded before parsing. Teamocil evaluates no templates, so
-the same text in a Teamocil source is preserved literally. Optional saves publish files atomically;
-`--force` permits replacement. Capture records current commands, directories,
-window names, indexes, focus, layouts, local session/window options and session
-environment values. It cannot recover original arguments, scripts or plugin
-intent. Removed environment entries and global options are omitted. Values are
-captured literally; loading a capture applies normal tmuxp-compatible variable
-expansion. Search uses native ICU regular expressions without Python.
-
-Capture selects an explicit session name or ID, then authenticated tmux context,
-then the only live session. Ambiguous human calls offer a choice; machine calls
-require an explicit target. A `.json` destination selects JSON unless `-f`
-overrides it; other destinations default to YAML. `--quiet` suppresses human
-status and warnings while preserving machine results and required errors.
-
-Every command accepts `--json` and `--ndjson`; NDJSON takes precedence. Listing
-and search decode documents on demand; load emits sequenced events and one
-terminal result while its output stream remains writable. Human listing uses
-semantic colors and escapes terminal controls. Editor argv is passed directly;
-machine editor calls return bounded captures in their result. Bootstrap
-and captured shell calls also stream decoded text as structured stderr warnings.
-The [child output contract](../output/#native-swift-child-output) describes
-stream limits, filtering and cancellation.
-
-`--log-level` filters advisory diagnostics at debug, info, warning, error or
-critical severity. Fatal operation errors remain visible. `load --log-file`
-opens a regular append file before backend work and writes structured lifecycle
-and diagnostic records at the selected level. New files use owner-only
-permissions. A later log-write error reports a secondary diagnostic without
-replacing the operation result.
-
-Human load displays event-driven progress on terminal stderr.
-`--progress-format` accepts five presets or a custom counter template;
-`TMUXP_PROGRESS_FORMAT` supplies the default. `--progress-lines` sets the recent
-bootstrap-output panel: 3 rows by default, 0 hides it and -1 uses the initial
-terminal height. `TMUXP_PROGRESS_LINES` supplies its default. The panel retains
-at most 65,536 UTF-8 bytes and clips Unicode conservatively. It samples terminal
-size once and does not track resizing. Bootstrap output streams while the script
-runs, preserving its original stdout or stderr destination.
-
-`--no-progress`, `TMUXP_PROGRESS=0`, `TERM=dumb`, redirected stderr and machine
-output disable the display. NDJSON receives discrete window/pane events.
-Completion and interruption clear the panel. SIGINT and SIGTERM return status
-130 and terminate captured children.
-
-Python shell execution checks tmuxp 1.74.0 through `TMUX_WORKSPACE_PYTHON`,
-defaulting to `python3`. Machine shell calls require `-c`; interactive backends
-require a terminal. Shell completion can be generated from ArgumentParser. The
-locally installed Linux executable still requires Swift runtime libraries.
-
-The [native source reference](https://github.com/libtmux/libtmux-swift/blob/528c5a8f5a4a699b7742a0c38e5075f386e11138/Sources/TmuxWorkspaceCLI/README.md)
-describes this implementation. Use the native executable's `--help` for the
-options implemented in that checkout.
-
-### Remaining gaps
-
-- Window/pane environment, shell overrides, command timing/readiness, plugins
-  and custom builders are not implemented in native loading.
-- Optional interactive Python backends, editor job control and broader
-  descendant cleanup need further testing.
-- Full capture/configuration coverage, generated manuals, Darwin validation
-  and portable distribution remain open. Building without the YAML trait does
-  not provide YAML commands.
-
-## Historical builder audit
-
-Audit date: 2026-09-09. [Native source snapshot](https://github.com/libtmux/libtmux-swift/tree/94b9e4cc436dda8e18e064179ae7d26e55bbbd73).
-The following results describe that original library revision, before the local
-CLI implementation. They are historical evidence, not its current capability
-list or a support guarantee for a published artifact.
-
-With optional YAML decoding enabled, the library parsed 23 upstream examples in
-the original audit but could silently omit unsupported keys. The first-pane
-explicit shell override was missing. YAML was absent from the default build, and
-the source snapshot had no native CLI.
-
-At that baseline, `TmuxWorkspace` supported JSON and optional YAML through the
-`YAMLWorkspaces` trait. Its model covered names, directories, layouts and
-commands with narrower shapes than tmuxp and could ignore unknown keys. Those
-library decoder results do not describe current CLI execution preflight.
-
-Read the port's [builder topics](../../internals/topics/) and
-[API](../) for its library interface. Use the language switcher
-to compare the same topic across ports; each port has its own coverage limits.
-
-## Shared gaps
-
-Parser acceptance does not prove execution support. Native regex engines and
-Python plugin runtimes have different contracts; identical flags alone do not
-establish compatibility. See [shell](../../cli/shell/),
-[search](../../cli/search/) and [hooks](../../configuration/hooks/), and apply
-this port's current limitations above when reading those reference pages.
-
-## Optional format separator
-
-Python libtmux exposes `LIBTMUX_TMUX_FORMAT_SEPARATOR` in its format collector.
-This native CLI does not claim that setting as a supported codec control. Its
-framing and decoding need their own compatible seam and collision, empty value,
-Unicode and line-break checks before accepting such a setting.
-
-## Reading examples
-
-The [gallery](../../examples/gallery/) contains the upstream fixture corpus.
-Parsing a fixture and executing its applications are separate checks. Several
-require external programs, remote hosts, project directories or plugin
-packages. A successful YAML read does not establish those dependencies or the
-complete workspace behavior.
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+[CLI source](https://github.com/libtmux/libtmux-swift/blob/53c67947879f4976ddf2c43f3c8df7c7671c5b19/Sources/TmuxWorkspaceCLI/README.md).
diff --git a/site/src/content/docs/ports/ts/examples/capture-pane-output.md b/site/src/content/docs/ports/ts/examples/capture-pane-output.md
new file mode 100644
index 00000000..edcd178a
--- /dev/null
+++ b/site/src/content/docs/ports/ts/examples/capture-pane-output.md
@@ -0,0 +1,115 @@
+---
+port: ts
+route: examples/capture-pane-output
+title: Capture pane output
+description: Run a complete program that captures a pane and waits for a complete output line.
+sidebar:
+  label: Capture pane output
+  group: Examples
+  order: 3
+tableOfContents: true
+---
+
+A pane runs asynchronously: sending a command does not mean its output is
+already on screen. Capture repeatedly until the expected line appears, with a
+deadline so a failed command cannot leave the program waiting forever.
+
+This complete program creates a private tmux server, captures its output, and
+cleans up. Follow the [setup and run instructions](#setup-and-run) below. You need
+tmux and a Unix environment; no existing tmux session is required.
+
+## Read what's on screen
+
+The program sends `printf` with a leading newline, then waits for the complete
+line `libtmux capture ready`. The newline keeps a late shell prompt off that
+line. Matching the whole line avoids mistaking the echoed command for its output.
+
+```typescript title="capture.ts"
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { Server } from "libtmux";
+
+const directory = await mkdtemp(join(tmpdir(), "libtmux-capture-"));
+const server = new Server({
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  timeoutMs: 5_000,
+});
+const failures: unknown[] = [];
+try {
+  const signal = AbortSignal.timeout(5_000);
+  const session = await server.newSession({
+    name: "capture", shellCommand: "sh", signal,
+    environment: { ENV: "/dev/null" },
+  });
+  const pane = session.activePane;
+  if (!pane) throw new Error("The session has no active pane");
+  await pane.sendKeys("printf '\\nlibtmux capture ready\\n'", { signal });
+  for (;;) {
+    const lines = await pane.capture({ signal });
+    const line = lines.find((line) => line === "libtmux capture ready");
+    if (line !== undefined) {
+      console.log(line);
+      break;
+    }
+    await delay(20, undefined, { signal });
+  }
+} catch (error) {
+  failures.push(error);
+} finally {
+  try {
+    if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
+    await rm(directory, { recursive: true });
+  } catch (error) {
+    failures.push(new Error(
+      `Cleanup failed; inspect ${directory}`, { cause: error },
+    ));
+  }
+}
+if (failures.length > 0) throw new AggregateError(failures, "Capture failed");
+```
+
+Cleanup checks the private socket even if startup fails. If stopping tmux fails,
+the error reports the retained directory so the server remains reachable.
+
+<a id="wait-for-text-instead-of-guessing-a-delay"></a>
+
+## Wait for output or completion
+
+The program above checks the captured screen for up to five seconds. The short
+pause between checks limits polling; the observed output determines when the loop
+finishes. A tmux capture is a view of the screen and scrollback, so it can miss
+output that has already scrolled away. Use a stream or a completion signal for
+long-running commands when that distinction matters.
+
+[Capturing output](/guides/capturing-output/) covers capture options, while
+[Sending keys](/guides/sending-keys/#the-race-you-cant-see-from-the-call-site)
+explains why sending and waiting are separate operations.
+
+## Setup and run
+
+Use an empty directory. The commands pin the library
+revision used to verify the program.
+
+Save the program as `capture.ts` and this file as `package.json`.
+Use Bun 1.4.2 or newer.
+
+```json title="package.json"
+{"type":"module","dependencies":{"libtmux":"file:./libtmux/packages/libtmux"}}
+```
+
+```console
+$ git clone https://github.com/libtmux/libtmux-ts libtmux &&
+  git -C libtmux checkout 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f &&
+  bun install &&
+  bun run capture.ts
+```
+
+<a id="source-inclusion"></a>
+
+## Where this comes from
+
+This complete program was run against the library revision pinned above.
+The displayed code is checked against the bytes from that run.
diff --git a/site/src/content/docs/ports/ts/mcp/examples.md b/site/src/content/docs/ports/ts/mcp/examples.md
index 1b1dbce3..5b75ada9 100644
--- a/site/src/content/docs/ports/ts/mcp/examples.md
+++ b/site/src/content/docs/ports/ts/mcp/examples.md
@@ -1,6 +1,6 @@
 ---
 title: TypeScript MCP examples
-description: List sessions through the TypeScript MCP server and inspect implementation examples.
+description: Connect an embedded TypeScript MCP client and list a private tmux session.
 port: ts
 product: mcp
 sidebar:
@@ -8,13 +8,12 @@ sidebar:
   order: 3
 ---
 
-Connect the server using the [setup guide](../guides/), then call
-[`list_sessions`](../tools/list_sessions/) from your MCP client.
+Connect a client using the [setup guide](../guides/), then call
+[`list_sessions`](../tools/list_sessions/).
 
 ## List sessions
 
-This is the `params` object for an MCP `tools/call` request. Send it
-through the connected client:
+Send this params object through the connected client's MCP tools/call request:
 
 ```json
 {
@@ -23,59 +22,162 @@ through the connected client:
 }
 ```
 
-Use the returned session IDs when choosing a window or pane. The
-[tool reference](../tools/list_sessions/) describes this port's result
-and optional arguments.
+Use the returned session IDs when choosing a window or pane.
 
 ## Internals
 
-The following examples are for applications that embed or extend the server.
-Installing and connecting an MCP client does not require this code.
+The complete program below embeds a TypeScript MCP client and server with
+linked in-memory transports. It offers only `list_sessions`; a client that
+launches the stdio server does not need embedding code.
 
-The port's `mcp-agent` example connects an MCP client and server with linked
-in-memory transports. The same tool names and arguments are used over stdio.
+### Prepare the project
+
+Use Bun 1.4.2 or newer, Git, and tmux 3.2a or newer on Unix. Create an empty
+consumer directory:
+
+```console
+$ mkdir mcp-example && cd mcp-example
+```
+
+Fetch the source revision used by this example:
+
+```console
+$ git init libtmux-source && \
+    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-ts.git && \
+    git -C libtmux-source fetch --depth 1 origin 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \
+    git -C libtmux-source checkout --detach FETCH_HEAD
+```
+
+Create the project manifest. The core and MCP packages come from that source
+tree; the SDK version matches the MCP package's dependency:
+
+```json title="package.json"
+{
+  "private": true,
+  "type": "module",
+  "workspaces": [
+    "libtmux-source/packages/libtmux",
+    "libtmux-source/packages/mcp"
+  ],
+  "dependencies": {
+    "libtmux": "workspace:*",
+    "@libtmux/mcp": "workspace:*",
+    "@modelcontextprotocol/sdk": "1.30.0"
+  }
+}
+```
+
+The local workspaces keep the consumer and companion on the same core
+module from that checkout.
+
+Install the dependencies:
+
+```console
+$ bun install --production
+```
 
 ### Connect an embedded client
 
-This function comes from the
-[agent example](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/examples/mcp-agent/mcp-agent.ts).
-It accepts an existing libtmux `Server`.
+Create the program below. It starts a private tmux session, connects both sides
+of the transport, checks the offered tools, then calls
+[`list_sessions`](../tools/list_sessions/). Cleanup closes the MCP client
+and server before stopping tmux. Operation and cleanup failures stay visible.
 
-```typescript
+```typescript title="mcp.ts"
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { createTmuxMcpServer } from "@libtmux/mcp";
-import type { Server } from "libtmux/server";
-
-export async function connectAgent(server: Server): Promise<Client> {
-  const client = new Client({ name: "example", version: "0.0.0" });
+import { Server } from "libtmux";
+
+const directory = await mkdtemp(join(tmpdir(), "libtmux-mcp-example-"));
+const server = new Server({
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  environment: { ...process.env, ENV: "/dev/null", BASH_ENV: "/dev/null" },
+  timeoutMs: 5_000,
+});
+const failures: unknown[] = [];
+let client: Client | undefined;
+let mcp: ReturnType<typeof createTmuxMcpServer> | undefined;
+try {
+  await server.newSession({ name: "mcp-example", shellCommand: "/bin/cat" });
+  mcp = createTmuxMcpServer(server, {
+    callerEnvironment: {},
+    environment: { LIBTMUX_TOOLSETS: "", LIBTMUX_TOOLS: "list_sessions" },
+  });
+  client = new Client({ name: "example", version: "1.0.0" });
   const [clientSide, serverSide] = InMemoryTransport.createLinkedPair();
   await Promise.all([
-    createTmuxMcpServer(server, {
-      environment: { LIBTMUX_TOOLSETS: "inspect,execute" },
-    }).connect(serverSide),
-    client.connect(clientSide),
+    mcp.connect(serverSide), client.connect(clientSide, { timeout: 5_000 }),
   ]);
-  return client;
+  const offered = (await client.listTools(undefined, { timeout: 5_000 }))
+    .tools.map((tool) => tool.name);
+  if (offered.length !== 1 || offered[0] !== "list_sessions") {
+    throw new Error(`Unexpected tools: ${offered.join(", ")}`);
+  }
+  const result = await client.callTool(
+    { name: "list_sessions", arguments: {} }, undefined, { timeout: 5_000 },
+  );
+  if (result.isError) throw new Error(JSON.stringify(result.content));
+  const sessions = result.structuredContent?.sessions;
+  if (!Array.isArray(sessions) || sessions.length !== 1 ||
+      sessions[0]?.name !== "mcp-example") {
+    throw new Error("Expected the example's private session");
+  }
+  console.log(`tools: ${offered.join(", ")}`);
+  console.log(`sessions: ${sessions[0].name}`);
+} catch (error) {
+  failures.push(error);
+} finally {
+  for (const cleanup of [
+    () => client?.close(),
+    () => mcp?.close(),
+    async () => {
+      if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
+      await rm(directory, { recursive: true });
+    },
+  ]) {
+    try { await cleanup(); }
+    catch (error) { failures.push(error); }
+  }
 }
+if (failures.length > 0) throw new AggregateError(failures, "MCP example failed");
 ```
 
-The caller owns the returned client. Close it after use. The complete
-example adds helpers for `run_shell_command`, `wait_for_text`,
-`capture_since`, and topology creation.
+`newSession` can fail after starting tmux. Cleanup checks the owned socket
+even if that call did not return. If stopping tmux fails, the program keeps
+the socket directory and reports the error.
 
 ### Run the example's checks
 
-From the TypeScript repository after installing its dependencies:
+Run the program:
 
 ```console
-$ bun test examples/mcp-agent
+$ bun run mcp.ts
+```
+
+Expected output:
+
+```text
+tools: list_sessions
+sessions: mcp-example
 ```
 
-The [example tests](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/examples/mcp-agent/mcp-agent.test.ts)
-start real tmux on an isolated socket and drive it through the MCP client.
-They cover exit status, echoed command text, waits, and successive cursor
-reads. Rendering this excerpt does not execute those tests.
+An empty `LIBTMUX_TOOLSETS` plus one name in `LIBTMUX_TOOLS` selects only that
+operation. `callerEnvironment: {}` avoids importing the surrounding pane's
+identity into the embedded server. The explicitly configured `Server`
+selects the private socket.
+
+Use the result's structured session IDs for later tool requests. Check
+`isError` before reading successful output; the
+[tool reference](../tools/list_sessions/) describes its schema.
+
+[Embedded server source](https://github.com/libtmux/libtmux-ts/blob/3fe1ca654b81b8cbf4a13b777a001a3298c87a6f/packages/mcp/src/server.ts);
+[upstream agent example](https://github.com/libtmux/libtmux-ts/blob/3fe1ca654b81b8cbf4a13b777a001a3298c87a6f/examples/mcp-agent/mcp-agent.ts);
+[upstream example tests](https://github.com/libtmux/libtmux-ts/blob/3fe1ca654b81b8cbf4a13b777a001a3298c87a6f/examples/mcp-agent/mcp-agent.test.ts).
 
 For declarative application code, see
 [Workspace builder examples](../../workspace/internals/examples/).
diff --git a/site/src/content/docs/ports/ts/workspace/internals/examples.md b/site/src/content/docs/ports/ts/workspace/internals/examples.md
index f3b47153..0537fe50 100644
--- a/site/src/content/docs/ports/ts/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/ts/workspace/internals/examples.md
@@ -1,6 +1,6 @@
 ---
-title: "TypeScript workspace builder examples"
-description: "Internal examples for building and inspecting workspaces through the TypeScript API."
+title: TypeScript workspace builder examples
+description: Build and inspect a workspace on a private tmux server with TypeScript.
 port: ts
 product: workspace
 sidebar:
@@ -10,34 +10,134 @@ sidebar:
 tableOfContents: true
 ---
 
-The workspace example declares a development session, applies it through
-`@libtmux/workspace`, and provides cleanup that tolerates an absent session.
-It also shows the lower-level core API for constructing a session manually.
+Create a workspace with two windows and two editor panes, inspect the result,
+then stop its private tmux server. The `/bin/cat` commands keep panes open
+without depending on an application or log file.
+
+## Prepare the project
+
+Use Bun 1.4.2 or newer, Git, and tmux 3.2a or newer on Unix. Create an empty
+consumer directory:
+
+```console
+$ mkdir workspace-example && cd workspace-example
+```
+
+Fetch the source revision used by this example:
+
+```console
+$ git init libtmux-source && \
+    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-ts.git && \
+    git -C libtmux-source fetch --depth 1 origin 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \
+    git -C libtmux-source checkout --detach FETCH_HEAD
+```
+
+Create the project manifest. Both packages come from the same source tree:
+
+```json title="package.json"
+{
+  "private": true,
+  "type": "module",
+  "workspaces": [
+    "libtmux-source/packages/libtmux",
+    "libtmux-source/packages/workspace"
+  ],
+  "dependencies": {
+    "libtmux": "workspace:*",
+    "@libtmux/workspace": "workspace:*"
+  }
+}
+```
+
+The local workspaces keep the consumer and companion on the same core
+module from that checkout.
+
+Install the dependencies:
+
+```console
+$ bun install --production
+```
 
 ## Build and remove a workspace
 
-The `buildWorkspace` function applies `DEVELOPMENT_WORKSPACE`. Pass it the
-`Server` you want to use. `removeWorkspace` checks a fresh snapshot before
-killing the named session and returns whether a session was present.
+Create the program below. The bootstrap session keeps the private server
+running while the program sets its default shell and builds the workspace.
+Cleanup covers a failed build as well as a successful one.
 
-```typescript file="examples/workspace/workspace.ts"
+```typescript title="workspace.ts"
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Server } from "libtmux";
+import { applyWorkspace } from "@libtmux/workspace";
+
+const directory = await mkdtemp(join(tmpdir(), "libtmux-workspace-"));
+const server = new Server({
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  environment: { ...process.env, ENV: "/dev/null", BASH_ENV: "/dev/null" },
+  timeoutMs: 5_000,
+});
+const failures: unknown[] = [];
+try {
+  await server.newSession({ name: "bootstrap", shellCommand: "/bin/cat" });
+  await server.setGlobalOption("session", "default-shell", "/bin/sh");
+  const session = await applyWorkspace(server, {
+    session_name: "workspace-example",
+    windows: [
+      { window_name: "editor", panes: ["/bin/cat", "/bin/cat"] },
+      { window_name: "logs", panes: ["/bin/cat"] },
+    ],
+  });
+  const windows = session.windows.toArray();
+  const editor = windows.find((window) => window.name === "editor");
+  if (windows.length !== 2 || editor?.panes.length !== 2) {
+    throw new Error("Expected two windows and two editor panes");
+  }
+  console.log(`built: ${windows.length} windows`);
+  console.log(`editor: ${editor.panes.length} panes`);
+} catch (error) {
+  failures.push(error);
+} finally {
+  for (const cleanup of [
+    async () => {
+      if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
+      await rm(directory, { recursive: true });
+    },
+  ]) {
+    try { await cleanup(); }
+    catch (error) { failures.push(error); }
+  }
+}
+if (failures.length > 0) throw new AggregateError(failures, "Workspace example failed");
 ```
 
-The `sleep` commands keep panes alive for inspection. They do not represent
-application readiness checks. Cleanup removes the session and its processes,
-so use a dedicated server or a session name owned by the example.
+`newSession` can fail after starting tmux. Cleanup checks the owned socket
+even if that call did not return. If stopping tmux fails, the program keeps
+the socket directory and reports the error.
 
 ## Verification
 
-The port's workspace integration suite calls this source against real tmux.
-From a prepared source checkout, run that suite with:
+Run the program:
 
 ```console
-$ bun test examples/workspace
+$ bun run workspace.ts
 ```
 
-The source include keeps this page's code aligned with the example. Rendering
-the page alone does not execute the integration suite. For a smaller runnable
-entry point, use the [application guide](../guides/).
+Expected output:
+
+```text
+built: 2 windows
+editor: 2 panes
+```
+
+`applyWorkspace` returns the built session snapshot. Its windows and panes
+reflect the completed build; request another snapshot after later changes.
+The program removes every session on the private server before exiting.
+
+For a workspace that stays open, let the application retain its explicitly
+selected server and choose when to stop it. A failed build can leave partial
+work; the example's server cleanup removes it.
 
-[Example source](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/examples/workspace/workspace.ts)
+[Example source](https://github.com/libtmux/libtmux-ts/blob/3fe1ca654b81b8cbf4a13b777a001a3298c87a6f/examples/workspace/workspace.ts);
+[Workspace builder source](https://github.com/libtmux/libtmux-ts/blob/3fe1ca654b81b8cbf4a13b777a001a3298c87a6f/packages/workspace/src/builder.ts).
diff --git a/site/src/content/docs/ports/ts/workspace/internals/index.md b/site/src/content/docs/ports/ts/workspace/internals/index.md
index d91e6e12..47acf438 100644
--- a/site/src/content/docs/ports/ts/workspace/internals/index.md
+++ b/site/src/content/docs/ports/ts/workspace/internals/index.md
@@ -10,9 +10,9 @@ sidebar:
 tableOfContents: true
 ---
 
-These pages document the in-development workspace builder for contributors
-and applications that call its APIs. For workspace loading from a terminal,
-see [tmuxp](https://tmuxp.git-pull.com/).
+Build and inspect tmux sessions from application code with the workspace
+library. To load files from a terminal, start with the
+[native CLI walkthrough](../guides/installation/).
 
 ## Builder pipeline
 
@@ -44,8 +44,8 @@ Node and Bun; its YAML convenience parser requires Bun. You can use validated
 JavaScript objects under either runtime. Real tmux control requires tmux on
 the host. The package documents Linux as its supported runtime platform.
 
-The workspace format uses familiar [tmuxp](https://tmuxp.git-pull.com) field
-names, with its own validation and convergence rules. Python plugins and
-tmuxp's configuration search are not part of this package.
+Read the [configuration and convergence rules](./topics/) before applying a
+description. The caller supplies input data; the library does not discover
+files or load runtime extensions.
 
 [Package documentation](https://github.com/libtmux/libtmux-ts/blob/f85b8de551353f746d50eaf36bf0112f4fe5a528/packages/workspace/README.md)
diff --git a/site/src/content/docs/ports/ts/workspace/reference/compatibility.md b/site/src/content/docs/ports/ts/workspace/reference/compatibility.md
index 89deefe7..7a3bc764 100644
--- a/site/src/content/docs/ports/ts/workspace/reference/compatibility.md
+++ b/site/src/content/docs/ports/ts/workspace/reference/compatibility.md
@@ -1,136 +1,45 @@
 ---
-title: "tmuxp compatibility and port status"
-description: "Current local CLI capabilities, remaining gaps, and the historical builder audit."
+title: Runtime and configuration support
+description: Runtime requirements and configuration boundaries for the TypeScript workspace command.
 port: ts
 product: workspace
 sidebar:
-  label: "tmuxp compatibility and port status"
+  label: Runtime and configuration support
   group: "Reference"
   order: 30
 tableOfContents: true
 ---
 
-**Local implementation, unpublished.** The TypeScript `tmux-workspace` CLI
-is available in the `workspace-cli` source worktree. Its command and
-configuration coverage remains partial. See [installation](../../guides/installation/)
-for local setup; installing a published library does not establish availability
-of this CLI.
+`tmux-workspace` is the TypeScript command for loading and capturing tmux
+workspaces. The [installation guide](../../guides/installation/) builds the
+documented source revision and runs a session on a private socket. The
+walkthroughs require tmux 3.2a or newer.
 
-Compatibility targets useful tmuxp 1.74.0 commands and workspace workflows, with
-native validation, execution and output conventions. Matching command names does
-not promise identical runtime behavior or Python semantics.
+## Runtime and execution
 
-## This port
+The CLI runs on Node.js 22 or newer and can be built with Bun. Use the
+installation guide for the documented revision. Ordinary load, capture,
+discovery, search, conversion and import use native services.
 
-The CLI runs on Node.js and Bun. Native services cover detached load, exact
-session reuse, append, capture, discovery, search, conversion, both importers,
-editor execution and diagnostics. Attached load uses the controlling terminal
-and selects its tmux client before building; unavailable terminals fail before
-session creation. Append authenticates the inherited server and current pane. A
-failed native bootstrap removes its created session and preserves a borrowed append
-session. Other failures report completed objects and the failed stage.
+Search uses JavaScript regular expressions. Explicit plugins, custom workspace
+builders and `shell` use an optional interpreter with tmuxp 1.74.0. Select it
+with `TMUX_WORKSPACE_PYTHON`. Empty extension selections keep native execution.
 
-Native loading supports command settings, directories, environment, shells,
-layouts, explicit window indexes, focus, options and before-script execution.
-Blank panes skip readiness checks. Conversion preserves extension fields;
-explicit saves require `--force` to replace an existing file. Capture recovers
-live state but cannot recover original command arguments, history or plugin
-intent. Native JavaScript regular expressions power search.
+The CLI and `@libtmux/workspace` are separate implementations. The library's
+convergence API and strict schema have a different contract from CLI loading.
 
-Capture accepts an explicit session name or ID, authenticated tmux context, or
-the only live session. Multiple sessions without context require an explicit
-target. A `.json` destination selects JSON unless `-f` overrides it; other
-destinations default to YAML. `--quiet` suppresses human save status while
-preserving machine results.
+## Configuration and failure handling
 
-Every command accepts `--json` and `--ndjson`; NDJSON takes precedence. Machine
-load requires `-d` or `--append` and never prompts. Human output has semantic
-colors and terminal progress with preset or custom formats. Log levels filter
-diagnostics, and `load --log-file` records them separately from result output.
-Child streams are bounded, escaped and streamed in NDJSON. `load -2` selects
-256-color mode; `-8` fails before workspace lookup or tmux access.
+Read [configuration](../../configuration/) for the CLI's fields. Unsupported
+execution fields fail visibly; generic [conversion](../../cli/convert/)
+preserves document values without proving that they can be executed.
 
-Python `shell` and explicit plugin/custom-builder loads require tmuxp 1.74.0 in
-the interpreter selected by `TMUX_WORKSPACE_PYTHON`, defaulting to `python3`.
-An interactive shell needs a controlling terminal. Ordinary loads and native
-read commands do not start Python. Empty plugin lists and blank builder names
-stay native.
+Use [machine output](../output/) for automation and check both the process
+status and any retained effects. Capture reads live tmux state; it cannot
+recover original command arguments, scripts, comments or application state.
 
-The load adapter expands common fields and resolves existing import directories
-relative to the workspace file. Explicit custom builders may omit `windows`.
-Append retains its authenticated target across inputs and rejects Python
-`before_script`. Extension progress shows a workspace label and script output
-without native pane counters.
+[Examples](../../examples/gallery/) provide complete starter documents. Their
+pane commands can need additional applications and directories when adapted.
+Use [library internals](../../internals/) for the programmatic builder.
 
-Extension results report `effects_scope: "observed"`, `effects_unknown: true`,
-and newly observed window and pane IDs. Concurrent changes may appear in these
-observations; the CLI does not infer ownership or roll back extension effects.
-Cancellation stops the owned Python process group, then allows up to one second
-to observe surviving topology. A daemon change or failed observation is reported
-without comparing IDs across daemon lifetimes.
-
-Native command references and Bash, Zsh and fish completion are generated from
-the parser. `completion` prints the selected shell script; machine modes return
-a structured script result. Static completion covers commands, options, enum
-values and file paths without running the CLI. Saved workspace names and live
-session values are outside its scope. Linux checks use Bash 5.2, Zsh 5.9 and
-fish 4.8; older shells and newline filenames remain unverified.
-
-Bare root/import groups in machine modes return a structured usage error with
-status 2 and empty stdout. Explicit help requests still print help.
-
-The local source reference is packages/workspace-cli/README.md. Use the native
-executable's `--help` for the options implemented in that checkout.
-
-### Remaining gaps
-
-- Interactive confirmation prompts remain unfinished.
-- Complete configuration/importer coverage, recoverability-aware capture and
-  platform acceptance remain open. Local installed-package checks on Node and
-  Bun do not establish support for every platform or workspace example.
-
-## Historical builder audit
-
-Audit date: 2026-09-09. [Native source snapshot](https://github.com/libtmux/libtmux-ts/tree/f85b8de551353f746d50eaf36bf0112f4fe5a528).
-The following results describe that original library revision, before the local
-CLI implementation. They are historical evidence, not its current capability
-list or a support guarantee for a published artifact.
-
-The library parsed 8 upstream YAML examples in the original audit. Its
-reconciliation builder could remove existing windows and panes, unlike tmuxp
-load policy. Capture/replay preserved the measured topology and directories, but
-was not a complete freezer. The source snapshot had no native CLI.
-
-At that baseline, `@libtmux/workspace` validated a strict subset. Its apply
-operation used ownership and command policies. Its YAML helper required Bun;
-Node callers needed a separate YAML decoder. These library observations do not
-describe the current CLI's YAML support or loading policy.
-
-Read the port's [builder topics](../../internals/topics/) and
-[API](../) for its library interface. Use the language switcher
-to compare the same topic across ports; each port has its own coverage limits.
-
-## Shared gaps
-
-Parser acceptance does not prove execution support. Native regex engines and
-Python plugin runtimes have different contracts; identical flags alone do not
-establish compatibility. See [shell](../../cli/shell/),
-[search](../../cli/search/) and [hooks](../../configuration/hooks/), and apply
-this port's current limitations above when reading those reference pages.
-
-## Optional format separator
-
-The TypeScript library reads `LIBTMUX_TMUX_FORMAT_SEPARATOR` when importing its
-`FORMAT_SEPARATOR` constant for direct format-list consumers. The workspace
-CLI's snapshot codec uses separate guarded framing; this setting does not change
-that transport or its decoding.
-
-## Reading examples
-
-The [gallery](../../examples/gallery/) contains the upstream fixture corpus.
-Parsing a fixture and executing its applications are separate checks. Several
-require external programs, remote hosts, project directories or plugin
-packages. A successful YAML read does not establish those dependencies or the
-complete workspace behavior.
-
-[tmuxp reference source](https://github.com/tmux-python/tmuxp/blob/618b398acc05506d3c682906c36cdeb29dcfa1ff/src/tmuxp/cli/__init__.py).
+[CLI source](https://github.com/libtmux/libtmux-ts/blob/f36d692552bb9a373b45338bb5fece854e57cc3d/packages/workspace-cli/README.md).
diff --git a/site/src/content/docs/topics/architecture.md b/site/src/content/docs/topics/architecture.md
index 2e51d209..ec05ec19 100644
--- a/site/src/content/docs/topics/architecture.md
+++ b/site/src/content/docs/topics/architecture.md
@@ -1,6 +1,7 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Architecture
-description: The object hierarchy underneath the API you call, and who actually holds the behavior in each port.
+description: Locate operations, distinguish snapshots from live commands, and find their implementation.
 sidebar:
   label: Architecture
   group: Topics
@@ -8,73 +9,73 @@ sidebar:
 tableOfContents: true
 ---
 
-This page describes how the language ports organize their code and where
-operations live. For the object hierarchy and stable IDs, start with [Server,
+A server handle selects a tmux server. Object IDs select sessions, windows, and
+panes within it. For the object hierarchy and stable IDs, start with [Server,
 session, window, pane](/concepts/server-session-window-pane/).
 
-## Where behavior lives: on the object, or through the server
+<a id="where-behavior-lives-on-the-object-or-through-the-server"></a>
 
-Python, TypeScript, Go, Rust, Java, .NET, and C++ provide operations on session,
-window, and pane objects. Each object carries its ID and server context. These
-examples send input, set an option, and kill a pane:
+## Calling operations
+
+<!-- port:py,ts,go,rs,java,dotnet,cxx -->
+Session, window, and pane handles carry their ID and server context. Call an
+operation on the object you want to change. The examples below send input and
+kill that pane.
+<!-- /port -->
 
 ```python
 pane.send_keys("echo hi")
-pane.set_option("automatic-rename", "off")
 pane.kill()
 ```
 
 ```typescript
 await pane.sendKeys("echo hi");
-await pane.setOption("automatic-rename", "off");
 await pane.kill();
 ```
 
 ```go
-pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &cmd})
-pane.SetOption(ctx, "automatic-rename", "off", tmux.SetOptionOptions{})
-pane.Kill(ctx)
+cmd := "printf 'hello\\n'"
+if err := pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &cmd, Literal: true}); err != nil {
+    return err
+}
+if err := pane.Kill(ctx); err != nil {
+    return err
+}
 ```
 
 ```rust
 pane.send_line("echo hi").await?;
-pane.set_option("automatic-rename", "off").await?;
 pane.kill().await?; // consumes the handle: see Context managers
 ```
 
 ```java
 pane.sendLine("echo hi");
-pane.options().set("automatic-rename", "off");
 pane.kill();
 ```
 
 ```csharp
 await pane.SendTextAsync("echo hi");
-await pane.Options.SetAsync(new SetOptionRequest("automatic-rename", "off"));
 await pane.KillAsync();
 ```
 
 ```cpp
 pane->send_text("echo hi");
-pane->set_option("automatic-rename", "off");
 pane->kill();
 ```
 
+<!-- port:swift -->
 Swift's `Session`, `Window`, and `Pane` are `Sendable` value types holding IDs
 and state fields. [Format-token fields](../format-tokens/) lists their fields.
 Perform operations through `Server`, passing the target value:
 
 ```swift
 try await server.sendKeys(["echo hi", "Enter"], to: pane)
-try await server.setOption("automatic-rename", to: "off", scope: .window(window))
 try await server.kill(pane)
 ```
 
-The practical effect is that `Server` is the one thing you hold onto in a
-Swift program; a `Session` or `Pane` you got back from a `snapshot()` is
-inert data you hand back to the server that produced it, not a handle you
-call things on. Every other port's `Server` is also where you start, but
-`Session`/`Window`/`Pane` stay live actors once you have one.
+Keep the `Server` that produced the snapshot. Pass its captured values back to
+that server for operations.
+<!-- /port -->
 
 ## A generated data table under a hand-written surface
 
@@ -84,62 +85,90 @@ catalogs, fixed field sets, or captured dictionaries:
 
 | Port | Generated table | Hand-written surface |
 |------|-------------------|----------------------|
-| Python | `libtmux.constants` (`FORMATS`, gated by scope and tmux version) | dataclass fields on `Obj` (`libtmux.neo`), `None` when a gate excludes a token |
-| TypeScript | `packages/libtmux/src/_generated/format_fields.ts` (`{ scope, since, token }` per row) | camelCase aliases on `Pane`/`Session`/`Window` (`packages/libtmux/src/_generated/field_aliases.ts`) |
-| Go | `format_generated.go`, `option_generated.go` (built by `internal/generate/formats`) | `(value, bool)` accessor methods: Go's own "comma ok" idiom for a gate |
-| Rust | `formats.rs`'s per-token macro rows (`token, wire name, scope, kind, since version, absent-handling`) | typed methods returning `Option<T>` |
-| Java | (typed field accessors generated for the query layer: see `Pane_`/`Session_` in [Filtering and queries](/concepts/queries/)) | `Optional<T>` for fields introduced after a port's tmux floor |
-| C++, Swift | fixed field sets; see below | a fixed, curated set of non-optional struct/class fields |
-| .NET | a snapshot dictionary read at capture time | typed properties that throw `IncompleteSnapshotException` for a field the capture didn't request, rather than gating on tmux version per field |
-
-Swift and C++ expose fixed sets of state fields. Swift includes indices,
-dimensions, active state, command, path, and edge flags. C++ declares its fields
-in `kFields` arrays and uses `pane->expand("#{...}")` for other tokens. See
-[Format-token fields](../format-tokens/) for optional fields and tokens outside
-the fixed sets.
-
-## Module layout, by port
-
-Each port's own top-level organization, to orient yourself before opening
-its source:
-
+<!-- port:py -->| Python | `libtmux.constants` (`FORMATS`, gated by scope and tmux version) | dataclass fields on `Obj` (`libtmux.neo`), `None` when a gate excludes a token |
+<!-- /port --><!-- port:ts -->| TypeScript | `packages/libtmux/src/_generated/format_fields.ts` (`{ scope, since, token }` per row) | camelCase aliases on `Pane`/`Session`/`Window` (`packages/libtmux/src/_generated/field_aliases.ts`) |
+<!-- /port --><!-- port:go -->| Go | `format_generated.go`, `option_generated.go` (built by `internal/generate/formats`) | `(value, bool)` accessor methods: Go's own "comma ok" idiom for a gate |
+<!-- /port --><!-- port:rs -->| Rust | `formats.rs`'s per-token macro rows (`token, wire name, scope, kind, since version, absent-handling`) | typed methods returning `Option<T>` |
+<!-- /port --><!-- port:java -->| Java | (typed field accessors generated for the query layer: see `Pane_`/`Session_` in [Filtering and queries](/concepts/queries/)) | `Optional<T>` for fields introduced after a port's tmux floor |
+<!-- /port --><!-- port:cxx -->
+| C++ | fixed field sets | non-optional fields |
+<!-- /port -->
+<!-- port:swift -->
+| Swift | fixed field sets | non-optional fields |
+<!-- /port -->
+<!-- port:dotnet -->| .NET | a snapshot dictionary read at capture time | typed properties that throw `IncompleteSnapshotException` for a field the capture didn't request, rather than gating on tmux version per field |
+<!-- /port -->
+<!-- port:swift -->
+The captured fields include indices, dimensions, active state, command, path,
+and edge flags. [Format-token fields](../format-tokens/) covers other tokens.
+<!-- /port -->
+<!-- port:cxx -->
+Use `pane->expand("#{...}")` for tokens outside the fixed fields.
+[Format-token fields](../format-tokens/) covers their interpretation.
+<!-- /port -->
+
+<a id="module-layout-by-port"></a>
+
+## Source layout
+
+Use these entry points when inspecting the implementation:
+
+<!-- port:py -->
 - **Python**: one module per tier (`libtmux.server`, `.session`, `.window`,
   `.pane`, `.client`), plus `libtmux.common` for shared plumbing,
   `libtmux.neo` for the dataclass query layer, `libtmux.options` /
   `libtmux.hooks` as mixins every tier includes, and `libtmux.exc` for the
   exception hierarchy.
+<!-- /port -->
+
+<!-- port:ts -->
 - **TypeScript**: `packages/libtmux/src/{server,session,window,pane,client}.ts`
   hold the public classes; nearly everything they call into lives under
   `_internal/operations/` (one file per concern: `pane_io.ts`, `hooks.ts`,
   `options.ts`, `topology.ts`) and `_generated/` (the format/option/hook
   catalogs above). Separate packages in the same monorepo cover workspaces
   (`@libtmux/workspace`) and an MCP server.
+<!-- /port -->
+
+<!-- port:go -->
 - **Go**: a single `tmux` package, split by concern into many files rather
   than many packages (`model.go` for the core structs, `lifecycle_kill.go`,
   `pane_capture.go`, `pane_geometry.go`, `hierarchy.go`, `plan_server.go`
   for folded invocations); `tmuxq` is a separate package for predicate
   queries over an already-read snapshot ([Filtering and
   queries](/concepts/queries/)), and `workspace` a separate one again.
+<!-- /port -->
+
+<!-- port:rs -->
 - **Rust**: `crates/libtmux/src/{server,session,window,pane}/` directories,
   each split into files by concern (a `settings.rs` per tier holding that
   tier's options-and-hooks methods, matching the pattern in [Options and
   hooks](../options-and-hooks/)); `hooks.rs`, `options.rs`, and `formats.rs`
   hold the shared, scope-generic machinery those call into. Workspaces and
   the MCP server are separate crates in the same workspace.
-- **Java**: `io.github.libtmux` holds `Server`, `Session`, `Window`, and
+<!-- /port -->
+
+<!-- port:java -->
+- **Java**: `libtmux/src/main/java/io/github/libtmux/` holds `Server`,
+  `Session`, `Window`, and
   `Pane` as `final` classes; each exposes its option and hook tables through
   `.options()` / `.hooks()` accessor methods returning a separate `Options`
   / `Hooks` view scoped to that object, rather than mixing those methods
-  directly into the entity class the way Python and Go do. `Session_`,
+  directly into the entity class. `Session_`,
   `Window_`, and `Pane_` are a parallel set of typed-field classes that
   exist only for the query layer.
+<!-- /port -->
+
+<!-- port:dotnet -->
 - **.NET**: `src/LibTmux/` gives every entity its own name (`Pane.cs`,
   `Session.cs`, ...) but splits each into several `partial class` files by
   concern rather than by inheritance: `Pane.Capture.cs`, `Pane.Input.cs`,
   `Pane.Relations.cs`, `Pane.Scopes.cs`, `Pane.Topology.cs`, and so on all
   contribute to one `Pane` type. `Options`/`Hooks` are reached through
-  `.Options` / `.Hooks` properties, structurally the same idea as Java's
-  accessor methods.
+  `.Options` / `.Hooks` properties.
+<!-- /port -->
+
+<!-- port:cxx -->
 - **C++**: `include/libtmux/entities.hpp` declares `Session`, `Window`, and
   `Pane` together as value types (`private Row` bases), with their method
   bodies in `src/` rather than the header; `server.hpp`, `options.hpp`, and
@@ -147,6 +176,9 @@ its source:
   A private `testing` component (`include/libtmux/testing/`) ships
   separately from the library proper: see [Context
   managers](../context-managers/) for what it's for.
+<!-- /port -->
+
+<!-- port:swift -->
 - **Swift**: `Sources/LibTmux/Server.swift` is the hub every operation
   extends; `Session.swift` and `Pane.swift` declare the thin value types,
   `Snapshot.swift` holds the relationship queries
@@ -154,10 +186,13 @@ its source:
   and `Mutations.swift` are `extension Server` files grouping options/hooks,
   send/capture, and kill respectively: all reachable only through `Server`,
   per the section above.
+<!-- /port -->
 
+<!-- port:root -->
 ## Naming conventions
 
 Method names follow language conventions: Python, Rust, and C++ use
 `snake_case`; TypeScript, Java, and Swift use `camelCase`; Go and .NET use
 `PascalCase`. Option and hook names remain tmux's dash-separated strings, such
 as `automatic-rename`, regardless of the method's spelling.
+<!-- /port -->
diff --git a/site/src/content/docs/topics/context-managers.md b/site/src/content/docs/topics/context-managers.md
index d985b130..9bae4729 100644
--- a/site/src/content/docs/topics/context-managers.md
+++ b/site/src/content/docs/topics/context-managers.md
@@ -1,8 +1,9 @@
 ---
-title: Context managers
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
+title: Ownership and cleanup
 description: Scope-based cleanup for tmux objects, and when your program must kill them explicitly.
 sidebar:
-  label: Context managers
+  label: Ownership and cleanup
   group: Topics
   order: 4
 tableOfContents: true
@@ -12,27 +13,33 @@ A tmux session, window, or pane normally remains until you kill it. Scope-based
 cleanup can kill it when your code leaves a block, including after an exception.
 See [Workspaces](/concepts/workspaces/) for a temporary layout example.
 
+<!-- port:root -->
 Python provides context managers for tmux objects. .NET provides ownership
 scopes for servers, sessions, and windows. Other ports require explicit cleanup
 or offer guards for test servers:
 
 | Port | Server | Session | Window | Pane |
 |------|:------:|:-------:|:------:|:----:|
-| Python | yes | yes | yes | yes |
-| .NET | yes | yes | yes | - |
-| Java | closes conn. | - | - | - |
-| Rust | test-only | - | - | - |
-| C++ | test-only | - | - | - |
-| TypeScript | - | - | - | - |
-| Go | - | - | - | - |
-| Swift | - | - | - | - |
-
+<!-- port:py -->| Python | yes | yes | yes | yes |
+<!-- /port --><!-- port:dotnet -->| .NET | yes | yes | yes | - |
+<!-- /port --><!-- port:java -->| Java | closes conn. | - | - | - |
+<!-- /port --><!-- port:rs -->| Rust | test-only | - | - | - |
+<!-- /port --><!-- port:cxx -->| C++ | test-only | - | - | - |
+<!-- /port --><!-- port:ts -->| TypeScript | - | - | - | - |
+<!-- /port --><!-- port:go -->| Go | - | - | - | - |
+<!-- /port --><!-- port:swift -->| Swift | - | - | - | - |
+<!-- /port -->
 "test-only" means a guard owns an entire disposable test server. Java's
 `AutoCloseable` server releases its transport but leaves tmux running. A dash
 means no built-in cleanup scope is listed for that object; use an explicit kill
 call with the cleanup mechanism appropriate to your language.
 
-## Python: every level, including nested
+<!-- /port -->
+
+<!-- port:py -->
+<a id="python-every-level-including-nested"></a>
+
+## Nested context managers
 
 Python's `Server`, `Session`, `Window`, and `Pane` support context managers.
 Entry returns the existing object; exit kills it, including when the block
@@ -48,8 +55,12 @@ with Server() as server:
 ```
 
 Nested scopes exit in reverse order: pane, window, session, then server.
+<!-- /port -->
 
-## .NET: an explicit ownership type, stopping at Window
+<!-- port:dotnet -->
+<a id="net-an-explicit-ownership-type-stopping-at-window"></a>
+
+## Owned sessions and windows
 
 .NET's `OwnedSessionScope` and `OwnedWindowScope` wrap the created object and
 implement `IAsyncDisposable`. The `Session` and `Window` handles themselves are
@@ -63,12 +74,16 @@ await window.Value.SendTextAsync("echo hello");
 // window, then session, killed on the way out
 ```
 
-There is no `OwnedPaneScope`. For tests,
+For tests that need an owned pane,
 `TmuxTestFactory.CreateHierarchyAsync()` returns a `TemporaryHierarchyScope`
 containing a private server, session, window, and pane. Disposing it kills the
 server.
+<!-- /port -->
+
+<!-- port:java -->
+<a id="java-server-is-closeable-but-closing-one-doesnt-kill-it"></a>
 
-## Java: `Server` is closeable, but closing one doesn't kill it
+## Closing a server connection
 
 Java's `Server` implements `AutoCloseable`. Exiting `try (Server server =
 Server.open(config))` releases the owned transport while tmux and its sessions
@@ -90,17 +105,21 @@ try (Server server = Server.open(config)) {
     // connection this `server` handle held is released on the way out.
 }
 ```
+<!-- /port -->
 
-## Rust: no async `Drop`, so cleanup is explicit or best-effort
+<!-- port:rs -->
+<a id="rust-no-async-drop-so-cleanup-is-explicit-or-best-effort"></a>
 
-Rust's `Drop::drop` is synchronous and cannot await an async tmux kill. Use
+## Explicit asynchronous cleanup
+
+Rust's `Drop` is synchronous and cannot await an async tmux kill. Use
 explicit shutdown when you need to observe cleanup failures:
 
 - **`kill(self)` consumes the handle.** Session, window, and pane kill methods
   take `self` by value, preventing subsequent use of that handle.
 - **`libtmux::test::TestServer` provides a test guard.** Call
-  `guard.shutdown().await?` to handle cleanup errors. Its `Drop` implementation
-  falls back to synchronous, best-effort `force_cleanup()`.
+  `TestServer.shutdown` to handle cleanup errors. Its `Drop` implementation
+  makes a synchronous cleanup attempt.
 
 ```rust
 use libtmux::test::TestServer;
@@ -114,8 +133,12 @@ session.new_window("editor").await?;
 // Await shutdown to handle cleanup errors.
 guard.shutdown().await?;
 ```
+<!-- /port -->
+
+<!-- port:cxx -->
+<a id="c-raii-exists-but-only-for-a-private-test-server"></a>
 
-## C++: RAII exists, but only for a private test server
+## Owning a test server
 
 C++'s `Session`, `Window`, and `Pane` are non-owning values; destroying a handle
 does not kill its tmux object. `libtmux::test::ScopedTmuxServer`, in the
@@ -128,45 +151,73 @@ auto fixture = libtmux::test::ScopedTmuxServer::start(
 // fixture killed, and its tree removed, when this scope ends:
 // even if the test that follows fails
 ```
+<!-- /port -->
+
+<!-- port:ts -->
+<a id="typescript-go-swift-no-built-in-scoping-at-all"></a>
+
+## Release connections and kill owned sessions
+
+Control connections and notification streams implement `[Symbol.asyncDispose]`.
+`await using` releases those handles; it leaves the watched session and panes
+running. Use `finally` to kill a session your program owns:
+
+```typescript
+const session = await server.newSession({ name: "work" });
+try {
+  const window = await session.newWindow({ name: "editor" });
+  await window.panes.at(0)?.sendKeys("echo hi");
+} finally {
+  await session.kill();
+}
+```
+<!-- /port -->
+
+<!-- port:go -->
+## Defer cleanup with a fresh context
+
+A `Session`, `Window`, or `Pane` handle does not own its tmux object. Dropping
+the value leaves tmux running. Register cleanup after successful creation and
+use a separate, bounded context so cancellation of the work cannot prevent
+cleanup. Return cleanup failures along with any work failure:
+
+```go
+func temporarySession(ctx context.Context, server tmux.Server) (err error) {
+    session, err := server.NewSession(ctx, tmux.NewSessionRequest{})
+    if err != nil {
+        return err
+    }
+    defer func() {
+        cleanup, cancel := context.WithTimeout(context.Background(), time.Second)
+        defer cancel()
+        err = errors.Join(err, session.Kill(cleanup))
+    }()
+    _, err = session.SearchWindows(ctx, nil)
+    return err
+}
+```
+
+This function uses `context`, `errors`, `time`, and the `tmux` package. It owns
+only the session it creates. Do not kill a shared server as session cleanup.
+
+`ControlClient`, `PaneObservation`, and `NotificationStream` implement
+`io.Closer`. Close those resources separately from killing tmux objects.
+For tests, `tmuxtest.NewServer` registers isolated server cleanup with the
+Go test runner.
+<!-- /port -->
+
+<!-- port:swift -->
+## Kill objects your program owns
+
+Session, window, and pane values are non-owning. Call
+`try await server.kill(session)` or the corresponding window or pane overload
+when cleanup is required. Perform cleanup on both success and failure paths;
+Swift's synchronous `defer` cannot await a tmux command.
+<!-- /port -->
+
+<a id="what-this-means-in-practice"></a>
 
-## TypeScript, Go, Swift: no built-in scoping at all
-
-TypeScript, Go, and Swift require explicit cleanup of sessions, windows, and
-panes. Connection or notification handles may have separate disposal APIs:
-
-- **TypeScript** implements `[Symbol.asyncDispose]` on control connections and
-  notification streams. `await using` releases those handles; it does not kill
-  the watched session or pane. See [Control mode vs
-  one-shot](/concepts/transports/). Use `finally` for a session your program
-  owns:
-
-  ```typescript
-  const session = await server.newSession({ name: "work" });
-  try {
-    const window = await session.newWindow({ name: "editor" });
-    await window.panes.at(0)?.sendKeys("echo hi");
-  } finally {
-    await session.kill();
-  }
-  ```
-
-- **Go** implements `io.Closer` on `ControlClient`, `PaneObservation`, and
-  `NotificationStream`. Use `defer conn.Close()` for those resources and an
-  explicit `Kill(ctx)` for tmux objects:
-
-  ```go
-  session, err := server.NewSession(ctx, tmux.NewSessionRequest{Name: "work"})
-  if err != nil {
-      return err
-  }
-  defer session.Kill(ctx) // idiomatic Go: not a library-provided guarantee
-  ```
-
-- **Swift** uses non-owning session, window, and pane values. Call `try await
-  server.kill(session)` or the corresponding window or pane overload when
-  cleanup is required.
-
-## What this means in practice
+## Testing cleanup
 
 Use explicit cleanup for objects whose handles have no disposal hook. For an
 entire disposable test server, prefer your port's test fixture or server guard;
diff --git a/site/src/content/docs/topics/environment.md b/site/src/content/docs/topics/environment.md
index c96a8db9..e18e1376 100644
--- a/site/src/content/docs/topics/environment.md
+++ b/site/src/content/docs/topics/environment.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Environment
 description: Locate tmux objects from process variables and manage the environment inherited by new panes.
 sidebar:
@@ -18,9 +19,12 @@ hooks](../options-and-hooks/), this persistent store has explicit scopes.
 
 Inside a pane, `TMUX` contains `<socket path>,<server pid>,<session id>`, and
 `TMUX_PANE` contains the pane ID, such as `%1`. Use these variables to locate
-the current tmux objects. Ports expose different levels of environment lookup:
+the current tmux objects. Select the object your operation needs:
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 **Server:** `Server.from_env()`
 
@@ -29,8 +33,12 @@ the current tmux objects. Ports expose different levels of environment lookup:
 **Window:** `Window.from_env()`
 
 **Pane:** `Pane.from_env()`
+<!-- /port -->
 
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 **Server:** Not listed.
 
@@ -39,8 +47,12 @@ the current tmux objects. Ports expose different levels of environment lookup:
 **Window:** Not listed.
 
 **Pane:** Not listed.
+<!-- /port -->
 
+<!-- port:go -->
+<!-- port:root -->
 ### Go
+<!-- /port -->
 
 **Server:** `NewServerFromEnv(env)`
 
@@ -49,8 +61,12 @@ the current tmux objects. Ports expose different levels of environment lookup:
 **Window:** `WindowFromEnv(ctx, env)`
 
 **Pane:** `PaneFromEnv(ctx, env)`
+<!-- /port -->
 
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 **Server:** `Server::from_env()`
 
@@ -59,8 +75,12 @@ the current tmux objects. Ports expose different levels of environment lookup:
 **Window:** `Window::from_env(&server)`
 
 **Pane:** `Pane::from_env(&server)`
+<!-- /port -->
 
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
 **Server:** Not listed.
 
@@ -69,8 +89,12 @@ the current tmux objects. Ports expose different levels of environment lookup:
 **Window:** Not listed.
 
 **Pane:** See the Java context example below.
+<!-- /port -->
 
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 **Server:** `Server.FromEnvironment(env)`
 
@@ -79,8 +103,12 @@ the current tmux objects. Ports expose different levels of environment lookup:
 **Window:** `Window.FromEnvironmentAsync()`
 
 **Pane:** `Pane.FromEnvironmentAsync()`
+<!-- /port -->
 
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
 **Server:** `Server::from_env()`
 
@@ -89,8 +117,12 @@ the current tmux objects. Ports expose different levels of environment lookup:
 **Window:** Not listed.
 
 **Pane:** Not listed.
+<!-- /port -->
 
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 **Server:** `TmuxContext.current()`
 
@@ -99,13 +131,16 @@ the current tmux objects. Ports expose different levels of environment lookup:
 **Window:** Not listed.
 
 **Pane:** Not listed.
+<!-- /port -->
 
 ### Examples
 
-Python, Go, and .NET provide standalone environment lookups at each level.
-Rust's `Session`, `Window`, and `Pane::from_env` require an existing `&Server`.
-TypeScript provides `Session.fromEnv()`; this page lists no equivalent for its
-other object types.
+<!-- port:rs -->
+`Session`, `Window`, and `Pane::from_env` require an existing `&Server`.
+<!-- /port -->
+<!-- port:ts -->
+Use `Session.fromEnv()` to resolve the session of the current process.
+<!-- /port -->
 
 ```python
 Pane.from_env().pane_id
@@ -119,10 +154,11 @@ const session = await Session.fromEnv();
 ```
 
 ```go
-pane, err := tmux.PaneFromEnv(ctx, nil) // nil reads the real process environment
-window, err := tmux.WindowFromEnv(ctx, nil)
-session, err := tmux.SessionFromEnv(ctx, nil)
-server, err := tmux.NewServerFromEnv(nil)
+pane, err := tmux.PaneFromEnv(ctx, nil)
+if err != nil {
+    return err
+}
+fmt.Println("current pane:", pane.ID())
 ```
 
 ```rust
@@ -139,34 +175,51 @@ Window window = await Window.FromEnvironmentAsync();
 Pane pane = await Pane.FromEnvironmentAsync();
 ```
 
-A process not started inside a pane has nothing truthful to answer with, so
-every one of these raises rather than guessing: Python's `NotInsideTmux`,
-Go's `FromEnvError`, .NET's `TmuxObjectNotFoundException`, and so on, each
-naming the missing or malformed variable rather than returning an empty or
-default object.
+Environment lookup requires valid tmux targeting variables. If your process
+can run outside tmux, handle that case before using the result.
 
-### Java and C++ stop short of the pane
+<!-- port:py -->
+`NotInsideTmux` reports a missing or invalid tmux environment.
+<!-- /port -->
+<!-- port:go -->
+Check the returned `error`. A `FromEnvError` identifies a missing or malformed
+variable. Passing `nil` reads the process environment; pass an explicit map to
+resolve a captured environment.
+<!-- /port -->
+<!-- port:dotnet -->
+Handle `TmuxObjectNotFoundException` when the environment cannot identify an
+object.
+<!-- /port -->
 
-Neither port gives you a live object back the way the other five do, and
-they stop at different points:
+<!-- port:cxx -->
+<a id="java-and-c-stop-short-of-the-pane"></a>
 
-- **C++** provides `Server::from_env()` to select the socket. Use the resulting
-  server to resolve sessions or panes.
-- **Java** parses `TMUX` and `TMUX_PANE` into identifiers: socket path, server
+### Resolve the server socket
+
+`Server::from_env()` selects the socket. Use the resulting server to resolve
+sessions or panes.
+<!-- /port -->
+
+<!-- port:java -->
+### Resolve context identifiers
+
+`TmuxEnvironment` parses `TMUX` and `TMUX_PANE` into identifiers: socket path, server
   PID, `SessionId`, and `Optional<PaneId>`. It returns context data rather than
   a live pane handle:
 
-  ```java
-  TmuxEnvironment here = TmuxEnvironment.current().orElseThrow();
+```java
+TmuxEnvironment here = TmuxEnvironment.current().orElseThrow();
 
-  try (Server server = Server.open(here.config())) {
-      Session mine = server.sessions().stream()
-              .filter(session -> session.id().equals(here.session()))
-              .findFirst()
-              .orElseThrow();
-  }
-  ```
+try (Server server = Server.open(here.config())) {
+    Session mine = server.sessions().stream()
+          .filter(session -> session.id().equals(here.session()))
+          .findFirst()
+          .orElseThrow();
+}
+```
+<!-- /port -->
 
+<!-- port:swift -->
 <a id="swift-reads-less-than-it-could"></a>
 
 ### Swift context fields
@@ -182,56 +235,79 @@ let server = try context.server()
 
 Read `TMUX_PANE` separately if you need the pane ID; `TmuxContext` does not
 provide it.
+<!-- /port -->
 
 ## tmux's own environment variable store
 
-Like [Options and
-hooks](../options-and-hooks/#window-and-pane-hook-scopes-are-mostly-fiction),
+Like [Options and hooks](../options-and-hooks/),
 tmux's persistent environment store has global and per-session scopes. It is
 read with `show-environment` and updated with `set-environment`. Newly spawned
 processes inherit it; existing processes retain their own environments.
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 **Set:** `server.set_environment(name, value)`, `session.set_environment(...)`
 
 **Read all:** `server.show_environment()`, `session.show_environment()`
 
 **Unset:** `server.unset_environment(name)`. See below for `.remove_environment()`.
+<!-- /port -->
 
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 **Set:** `server.setEnvironment(name, value)`, `session.setEnvironment(...)`
 
 **Read all:** `server.showEnvironment()`, `session.showEnvironment()`
 
 **Unset:** `server.unsetEnvironment(name)`, `session.unsetEnvironment(name)`
+<!-- /port -->
 
+<!-- port:go -->
+<!-- port:root -->
 ### Go
+<!-- /port -->
 
 **Set:** `server.SetEnvironment(ctx, name, value, opts)` (global, `-g`)
 
 **Read all:** `server.ShowEnvironment(ctx)`
 
 **Unset:** `server.UnsetEnvironment(ctx, name)`
+<!-- /port -->
 
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 **Set:** `server.set_environment(...)`, `session.set_environment(...)`
 
 **Read all:** `server.environment_all()`, `session.environment_all()`
 
 **Unset:** `server.unset_environment(name)`, `session.unset_environment(name)`
+<!-- /port -->
 
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
-**Set:** Not documented here; see the Java and C++ note below.
+**Set:** Not documented here; see the process-environment note below.
 
-**Read all:** Not documented here; see the Java and C++ note below.
+**Read all:** Not documented here; see the process-environment note below.
 
-**Unset:** Not documented here; see the Java and C++ note below.
+**Unset:** Not documented here; see the process-environment note below.
+<!-- /port -->
 
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 **Set:** `server.Environment.SetAsync(name, value)`,
 `session.Environment.SetAsync(...)`
@@ -239,16 +315,24 @@ processes inherit it; existing processes retain their own environments.
 **Read all:** `server.Environment.GetAllAsync()`
 
 **Unset:** `server.Environment.UnsetAsync(name)`, `.RemoveAsync(name)`
+<!-- /port -->
 
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
-**Set:** Not documented here; see the Java and C++ note below.
+**Set:** Not documented here; see the process-environment note below.
 
-**Read all:** Not documented here; see the Java and C++ note below.
+**Read all:** Not documented here; see the process-environment note below.
 
-**Unset:** Not documented here; see the Java and C++ note below.
+**Unset:** Not documented here; see the process-environment note below.
+<!-- /port -->
 
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 **Set:** `server.setEnvironment(name, to: value, in: scope)`
 
@@ -256,7 +340,9 @@ processes inherit it; existing processes retain their own environments.
 
 **Unset:** `server.unsetEnvironment(name, in: scope)`, `.removeEnvironment(name,
 in:)`
+<!-- /port -->
 
+<!-- port:py,ts,go,rs,dotnet,swift -->
 ### Examples
 
 ```python
@@ -272,9 +358,14 @@ await session.showEnvironment();
 ```
 
 ```go
-server.SetEnvironment(ctx, "EDITOR", "vim", tmux.SetEnvironmentOptions{})
-session.SetEnvironment(ctx, "EDITOR", "hx", tmux.SetEnvironmentOptions{})
-session.ShowEnvironment(ctx)
+if err := session.SetEnvironment(ctx, "EDITOR", "hx", tmux.SetEnvironmentOptions{}); err != nil {
+    return err
+}
+values, err := session.ShowEnvironment(ctx)
+if err != nil {
+    return err
+}
+fmt.Println(values)
 ```
 
 ```rust
@@ -295,18 +386,36 @@ try await server.setEnvironment("EDITOR", to: "hx", in: .session(session.id.rawV
 try await server.environment(.session(session.id.rawValue))
 ```
 
-Python's `set_environment` writes a value, and `unset_environment` (`-u`)
-removes the entry. `remove_environment` (`-r`) marks the variable for exclusion
-from new processes, including when tmux inherited it at server startup; the
-listing retains it as `-NAME`. Swift exposes the same distinction through
-`setEnvironment`, `unsetEnvironment`, and `removeEnvironment`. A remove
-operation is not documented here for TypeScript, Go, or Rust.
+<!-- /port -->
+
+`set-environment` writes a value. Its `-u` flag removes the entry, while `-r`
+marks the variable for exclusion from new processes, including values tmux
+inherited at startup. The listing retains an excluded variable as `-NAME`.
+
+<!-- port:py -->
+Use `unset_environment` for `-u`, or `remove_environment` for `-r`.
+<!-- /port -->
+<!-- port:swift -->
+Use `unsetEnvironment` for `-u`, or `removeEnvironment` for `-r`.
+<!-- /port -->
+<!-- port:dotnet -->
+Use `.UnsetAsync` for `-u`, or `.RemoveAsync` for `-r`.
+<!-- /port -->
+
+<!-- port:java -->
+<a id="java-and-c-no-verified-access-to-this-table-at-all"></a>
 
-### Java and C++: no verified access to this table at all
+### Process environment
 
-Java and C++ examples here cover environment values supplied at process
-creation, not reads or writes to an existing persistent table. Java's
 `SessionSpec.Builder.environment(Map)`, `WindowSpec.Builder.environment(Map)`,
-and `SplitSpec.Builder.environment(Map)` pass initial variables to `new-session
--e`, `new-window -e`, and `split-window -e`. Consult the port reference if you
-need to change the environment of an existing session.
+and `SplitSpec.Builder.environment(Map)` pass initial variables to
+`new-session -e`, `new-window -e`, and `split-window -e`. These creation options
+do not change the stored environment of an existing session.
+<!-- /port -->
+<!-- port:cxx -->
+### Process environment
+
+Creation-time environment values affect the new process. They do not update
+an existing process's environment. To change tmux's persistent table, use
+`set-environment` on the same socket as the server handle.
+<!-- /port -->
diff --git a/site/src/content/docs/topics/errors-and-exceptions.md b/site/src/content/docs/topics/errors-and-exceptions.md
index 48b1e970..17e7afa7 100644
--- a/site/src/content/docs/topics/errors-and-exceptions.md
+++ b/site/src/content/docs/topics/errors-and-exceptions.md
@@ -1,6 +1,7 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Errors and exceptions
-description: What a failed tmux command becomes in each port, and the question every one of them has to answer before letting you retry it.
+description: Handle command failures, inspect delivery status, and decide when a retry is safe.
 sidebar:
   label: Errors and exceptions
   group: Topics
@@ -20,21 +21,23 @@ queries](/concepts/queries/#the-cardinality-contract-side-by-side).
 
 | Port | How it fails | Base type |
 |------|--------------|-----------|
-| Python | throws | `LibTmuxException`: carries an optional `subcommand`; `str()` reads `"<subcommand>: <stderr>"` |
-| TypeScript | throws | `LibTmuxException extends Error`, with `TmuxCommandError` (tmux ran and refused) and `TmuxTransportError` (it didn't get an answer) as the two shapes that matter here |
-| Go | returns `(T, error)` | no shared base type: small typed `...Error` structs plus sentinel `errors.New` values, composed with `errors.Is` / `errors.As` and `%w` wrapping |
-| Rust | returns `Result<T, Error>` | one `Error` enum, `#[non_exhaustive]`, matched rather than caught |
-| Java | throws (unchecked) | `LibTmuxException extends RuntimeException` |
-| .NET | throws | `LibTmuxException`, with typed subclasses per failure (`TmuxCommandException`, `TmuxTransportException`, `TmuxObjectNotFoundException`, and a dozen more) |
-| C++ | returns `expected<T, CommandFailure>` | `CommandFailure { kind, delivery, exit_code, diagnostic }`: no exception type at all |
-| Swift | throws (typed) | `enum TmuxError: Error`, thrown as `throws(TmuxError)`: Swift's typed-throws syntax, not a bare `throws` |
-
-Rust and C++ return result values. Go returns an `error` that callers inspect
-with `errors.Is` or `errors.As`. Exception-based ports report failures through
-their exception hierarchies.
-
-TypeScript's own docs make the split between its two exception shapes
-concrete:
+<!-- port:py -->| Python | throws | `LibTmuxException`: carries an optional `subcommand`; `str()` reads `"<subcommand>: <stderr>"` |
+<!-- /port --><!-- port:ts -->| TypeScript | throws | `LibTmuxException extends Error`, with `TmuxCommandError` (tmux ran and refused) and `TmuxTransportError` (it didn't get an answer) as the two shapes that matter here |
+<!-- /port --><!-- port:go -->| Go | returns `(T, error)` | no shared base type: small typed `...Error` structs plus sentinel `errors.New` values, composed with `errors.Is` / `errors.As` and `%w` wrapping |
+<!-- /port --><!-- port:rs -->| Rust | returns `Result<T, Error>` | one `Error` enum, `#[non_exhaustive]`, matched rather than caught |
+<!-- /port --><!-- port:java -->| Java | throws (unchecked) | `LibTmuxException extends RuntimeException` |
+<!-- /port --><!-- port:dotnet -->| .NET | throws | `LibTmuxException`, with typed subclasses per failure (`TmuxCommandException`, `TmuxTransportException`, `TmuxObjectNotFoundException`, and a dozen more) |
+<!-- /port --><!-- port:cxx -->| C++ | returns `expected<T, CommandFailure>` | `CommandFailure { kind, delivery, exit_code, diagnostic }`: no exception type at all |
+<!-- /port --><!-- port:swift -->| Swift | throws (typed) | `enum TmuxError: Error`, thrown as `throws(TmuxError)`: Swift's typed-throws syntax, not a bare `throws` |
+<!-- /port -->
+<!-- port:go -->
+Use `errors.Is` for sentinel errors such as `tmux.ErrNoServer` and
+`tmux.ErrNotFound`. Use `errors.As` to inspect a `*tmux.CommandError` and its
+completed command result. Wrap errors with `%w` to preserve that information.
+<!-- /port -->
+
+<!-- port:ts -->
+Distinguish a command rejected by tmux from a transport failure:
 
 ```typescript
 import { TmuxCommandError, TmuxTransportError } from "libtmux";
@@ -53,6 +56,8 @@ try {
 }
 ```
 
+<!-- /port -->
+
 ## Is it safe to retry?
 
 Retry a mutation automatically only when you know it was not dispatched, or when
@@ -62,15 +67,17 @@ information:
 
 | Port | Name | States |
 |------|------|--------|
-| TypeScript | `TmuxTransportError.delivery` | `"not_started"` / `"written"` / `"replied"` / `"indeterminate"`: only `not_started` is safe to retry blindly |
-| .NET | `LibTmuxException.Dispatch` (`TmuxDispatchState`) | `NotDispatched` / `Dispatched` / `Unknown` (the default) |
-| Java | `DispatchOutcome`, via `TmuxTimeoutException.outcome()` | `NOT_DISPATCHED` / `COMPLETE` / `UNKNOWN` |
-| C++ | `DeliveryStatus` | `not_started` / `written` / `replied` / `indeterminate` |
-| Rust | `ControlModeErrorKind` (behind the `control-mode` feature) | `DispatchTimedOut` (safe to retry) vs. plain `TimedOut` (not: the connection may have already committed the command) |
-| Python, Go's one-shot path | - | inspect the exit status after normal completion; an interrupted call needs separate state verification |
-| Go's control-mode pool | handled internally, not exposed | a failed pooled connection is retired rather than reused, rather than handing the caller a retry-safety flag to check |
-| Swift | documented, not typed | `ControlSession`'s own doc comment states the same rule in prose ("a command that never reached tmux is safe to retry") without a dedicated enum |
-
+<!-- port:ts -->| TypeScript | `TmuxTransportError.delivery` | `"not_started"` / `"written"` / `"replied"` / `"indeterminate"`: only `not_started` is safe to retry blindly |
+<!-- /port --><!-- port:dotnet -->| .NET | `LibTmuxException.Dispatch` (`TmuxDispatchState`) | `NotDispatched` / `Dispatched` / `Unknown` (the default) |
+<!-- /port --><!-- port:java -->| Java | `DispatchOutcome`, via `TmuxTimeoutException.outcome()` | `NOT_DISPATCHED` / `COMPLETE` / `UNKNOWN` |
+<!-- /port --><!-- port:cxx -->| C++ | `DeliveryStatus` | `not_started` / `written` / `replied` / `indeterminate` |
+<!-- /port --><!-- port:rs -->| Rust | `ControlModeErrorKind` (behind the `control-mode` feature) | `DispatchTimedOut` (safe to retry) vs. plain `TimedOut` (not: the connection may have already committed the command) |
+<!-- /port --><!-- port:py,go -->| Process calls | - | inspect the exit status after normal completion; an interrupted call needs separate state verification |
+<!-- /port -->
+<!-- port:go -->| Control pool | connection retirement | a failed pooled connection is retired; its failure does not prove that a mutation was never dispatched |
+<!-- /port -->
+<!-- port:swift -->| Swift | documented, not typed | `ControlSession`'s own doc comment states the same rule in prose ("a command that never reached tmux is safe to retry") without a dedicated enum |
+<!-- /port -->
 ```typescript
 import { TmuxTransportError } from "libtmux";
 
@@ -101,10 +108,21 @@ if (!result.has_value() && result.error().delivery == libtmux::DeliveryStatus::n
 }
 ```
 
-A state such as `not_started`, `NotDispatched`, `NOT_DISPATCHED`, or
-`DispatchTimedOut` identifies a request that did not reach tmux. Treat unknown
-delivery as potentially executed. C++ and TypeScript also distinguish `written`,
-where the transport accepted the request but no terminal reply has arrived.
+Treat unknown delivery as potentially executed.
+
+<!-- port:cxx,ts -->
+A `not_started` result means the request did not reach tmux. A `written` result
+means the transport accepted the request but no terminal reply arrived.
+<!-- /port -->
+<!-- port:dotnet -->
+`NotDispatched` identifies a request that did not reach tmux.
+<!-- /port -->
+<!-- port:java -->
+`NOT_DISPATCHED` identifies a request that did not reach tmux.
+<!-- /port -->
+<!-- port:rs -->
+`DispatchTimedOut` identifies a request that did not reach tmux.
+<!-- /port -->
 
 For subprocess calls that complete normally, inspect the exit status. If a call
 is interrupted or times out without a delivery state, check tmux's resulting
diff --git a/site/src/content/docs/topics/format-tokens.md b/site/src/content/docs/topics/format-tokens.md
index 29658e51..f30c5a16 100644
--- a/site/src/content/docs/topics/format-tokens.md
+++ b/site/src/content/docs/topics/format-tokens.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Format-token fields
 description: The typed fields every object exposes, mirroring tmux's own format tokens, and why a field is sometimes absent.
 sidebar:
@@ -18,17 +19,24 @@ token needs a pane context, and a token added after your tmux release may be
 absent. Ports represent absence with optional values, flags, or errors, as
 described below.
 
-## The absence idiom, per port
+<a id="the-absence-idiom-per-port"></a>
+
+## Handling an absent field
 
 | Port | What an excluded field looks like |
 |------|--------------------------------------|
-| Python | the attribute is `None` |
-| TypeScript | the property is `undefined` |
-| Go | a two-return-value accessor: `pane.DeadSignal()` returns `(string, bool)`: Go's own "comma ok" idiom |
-| Rust | `Option<T>`; consult the reference for the accessor name |
-| Java | `Optional<T>`: `pane.floating()` returns `Optional<Boolean>`, empty when the field isn't populated |
-| .NET | nullable values or `IncompleteSnapshotException`, depending on whether the value or captured field is absent |
-| C++, Swift | fixed, non-optional fields; see below for access to other tokens |
+<!-- port:py -->| Python | the attribute is `None` |
+<!-- /port --><!-- port:ts -->| TypeScript | the property is `undefined` |
+<!-- /port --><!-- port:go -->| Go | a two-return-value accessor: `pane.DeadSignal()` returns `(string, bool)`: Go's own "comma ok" idiom |
+<!-- /port --><!-- port:rs -->| Rust | `Option<T>`; consult the reference for the accessor name |
+<!-- /port --><!-- port:java -->| Java | `Optional<T>`: `pane.floating()` returns `Optional<Boolean>`, empty when the field isn't populated |
+<!-- /port --><!-- port:dotnet -->| .NET | nullable values or `IncompleteSnapshotException`, depending on whether the value or captured field is absent |
+<!-- /port --><!-- port:cxx -->
+| C++ | fixed, non-optional fields; see below for other tokens |
+<!-- /port -->
+<!-- port:swift -->
+| Swift | fixed, non-optional fields; see below for other tokens |
+<!-- /port -->
 
 These examples read optional fields, including `pane_dead_signal` on tmux 3.3 or
 newer:
@@ -50,9 +58,12 @@ pane.floating(); // Optional<Boolean>: a different field, same idiom: empty
                   // rather than a sentinel when the token isn't populated
 ```
 
+<!-- port:rs -->
 Rust's `formats.rs` marks this token as optional. Consult its generated
 reference for the accessor name.
+<!-- /port -->
 
+<!-- port:dotnet -->
 .NET also distinguishes missing values from incomplete captures. `Pane.Title` is
 nullable because tmux may report no title. `Pane.Height`, `.Width`, and `.Index`
 throw `IncompleteSnapshotException` when the read that produced the handle did
@@ -64,42 +75,57 @@ string? title = pane.Title;   // nullable: the ordinary absence case
 int height = pane.Height;     // throws IncompleteSnapshotException instead,
                                // if this Pane wasn't captured with a full listing
 ```
+<!-- /port -->
+
+<a id="a-generated-table-under-the-accessor"></a>
 
-## A generated table under the accessor
+## Field availability
 
-Several ports generate scope- and version-tagged field catalogs from tmux source
-or documentation. [Architecture](../architecture/) describes the layouts.
-Examples include:
+Field accessors retain the scope and version requirements of tmux tokens.
 
+<!-- port:ts -->
 - **TypeScript** uses `_generated/format_fields.ts` rows with `scope`, `since`,
   and `token`. For example, `pane_zoomed_flag` has pane scope and requires tmux
   3.7. `_generated/field_aliases.ts` supplies the camelCase alias
   `pane.zoomedFlag`.
+<!-- /port -->
+
+<!-- port:rs -->
 - **Rust** uses a macro row in `formats.rs` for each token's wire name, scope,
   tmux version, and type. `pane_dead_signal` has `Pane` scope, requires `V3_3`,
-  and is decoded as `Text`.
+  and preserves arbitrary non-NUL bytes.
+<!-- /port -->
+
+<!-- port:go -->
 - **Go** generates `format_generated.go` with `internal/generate/formats`. Some
   accessors decode richer values: `pane.DeadTime()` returns `(time.Time, bool)`
   and performs timestamp parsing for the caller.
+<!-- /port -->
 
-Two per-token facts survive across every one of these catalogs, because
-they're facts about tmux, not about any one port's generator: `pane_dead_signal`
+Version gates describe tmux behavior: `pane_dead_signal`
 and `pane_dead_time` arrived in tmux 3.3, and a cluster of pane-geometry and
 floating-pane tokens (`pane_floating_flag`, `pane_pb_progress`, `pane_x`,
 `pane_y`, `pane_z`, `pane_zoomed_flag`, `bracket_paste_flag`,
 `synchronized_output_flag`, among others) arrived together in 3.7.
 
-## The two ports that didn't generate the full catalog
+<!-- port:cxx,swift -->
+<a id="the-two-ports-that-didnt-generate-the-full-catalog"></a>
+
+## Fixed fields and additional tokens
 
-Swift and C++ expose fixed, non-optional fields on `Session`, `Window`, and
-`Pane`:
+`Session`, `Window`, and `Pane` expose a fixed set of captured fields:
 
+<!-- port:swift -->
 - **Swift** carries `index`, `width`, `height`, `isActive`, `currentCommand`,
   `currentPath`, and the four edge flags.
+<!-- /port -->
+
+<!-- port:cxx -->
 - **C++** declares fields in `kFields` arrays. Pane fields include `id`,
   `command`, `active`, `index`, `title`, `pid`, `tty`, `path`, `width`,
   `height`, `dead`, `in_mode`, edge flags, and `piping`. Accessors return
   `std::string_view`, `bool`, or `long long`.
+<!-- /port -->
 
 ```swift
 pane.isActive       // Bool, not Bool?: always populated, never gated
@@ -111,14 +137,20 @@ pane->active();  // bool, not std::optional<bool>
 pane->command(); // std::string_view, likewise
 ```
 
-For a token outside the fixed fields, C++ provides one-shot expansion with
-`pane->expand("#{pane_dead_signal}")`. Swift uses `FormatSubscription` on a
-control connection, delivering `SubscriptionChange` when tmux re-evaluates the
-token. That API observes changes over time. [Architecture](../architecture/)
+<!-- port:cxx -->
+Expand a token outside the fixed fields with
+`pane->expand("#{pane_dead_signal}")`.
+<!-- /port -->
+<!-- port:swift -->
+Use `FormatSubscription` on a control connection to observe other tokens.
+It delivers `SubscriptionChange` when tmux re-evaluates the token.
+<!-- /port --> [Architecture](../architecture/)
 describes the fixed-field model.
+<!-- /port -->
 
 ## Fields promoted from the active child
 
+<!-- port:py -->
 Python exposes fields promoted from an active child. For example,
 `session.pane_id` identifies the active pane of the session's active window:
 
@@ -127,6 +159,7 @@ Python exposes fields promoted from an active child. For example,
 >>> session.pane_id == session.active_window.active_pane.pane_id
 True
 ```
+<!-- /port -->
 
 tmux's format engine includes active-child fields when listing a parent. A
 `list-sessions -F` row can include `window_id` and `pane_id` for the active
diff --git a/site/src/content/docs/topics/index.md b/site/src/content/docs/topics/index.md
index 75c795cd..0427919b 100644
--- a/site/src/content/docs/topics/index.md
+++ b/site/src/content/docs/topics/index.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Topics
 description: Object traversal, cleanup, pane I/O, configuration, and failure handling.
 sidebar:
@@ -16,10 +17,10 @@ The concept guides also cover [control mode vs one-shot](/concepts/transports/),
 behavior:
 
 - **[Architecture](architecture/)**: locate operations and field definitions in
-  each port's source.
+  the library source.
 - **[Traversal](traversal/)**: navigate related objects, test membership, and
   compare identity.
-- **[Context managers](context-managers/)**: manage cleanup on block exit and
+- **[Ownership and cleanup](context-managers/)**: manage cleanup on block exit and
   identify objects that need an explicit kill.
 - **[Pane interaction](pane-interaction/)**: choose input modes, capture ranges,
   and completion waits.
@@ -36,5 +37,5 @@ behavior:
 - **[Errors and exceptions](errors-and-exceptions/)**: handle command failures
   and determine whether a mutation can be retried.
 
-Use your port's API reference for signatures and defaults. These pages call out
-differences that affect how you use the APIs.
+Use your port's API reference for signatures and defaults. Each topic explains
+the behavior behind those calls.
diff --git a/site/src/content/docs/topics/options-and-hooks.md b/site/src/content/docs/topics/options-and-hooks.md
index 990787a9..781f7257 100644
--- a/site/src/content/docs/topics/options-and-hooks.md
+++ b/site/src/content/docs/topics/options-and-hooks.md
@@ -1,6 +1,7 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Options and hooks
-description: Reading and writing tmux's own configuration knobs, and binding commands to its events, at whichever scope you're holding.
+description: Read and update tmux options, and register commands for tmux events.
 sidebar:
   label: Options and hooks
   group: Topics
@@ -15,11 +16,13 @@ option or hook.
 
 ## Reading and writing options
 
-Read an option, set it, or unset it at a chosen scope. Ports differ in how they
-distinguish values set locally from effective values inherited from another
-scope:
+Read, set, or unset an option at its supported scope. Distinguish a local
+override from the effective value inherited from a parent scope.
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 **Read all (this scope):** `pane.show_options()`
 
@@ -30,7 +33,12 @@ global fallback explicitly; no separate "resolved" call
 
 **Unset:** `pane.unset_option(name)`
 
+<!-- /port -->
+
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 **Read all (this scope):** `pane.showOptions()`
 
@@ -40,18 +48,30 @@ global fallback explicitly; no separate "resolved" call
 
 **Unset:** `pane.unsetOption(name)`
 
+<!-- /port -->
+
+<!-- port:go -->
+<!-- port:root -->
 ### Go
+<!-- /port -->
 
-**Read all (this scope):** `pane.Options(ctx)`: a typed struct with one
-accessor method per option
+`pane.Options(ctx)` returns a fresh typed snapshot, including inherited values.
+Its accessors return an `OptionValue`; use `OptionValue.Get` to distinguish a
+present value from an absent one. Check the read error before inspecting the snapshot.
 
-**Read effective/inherited:** Not listed.
+Use the handle that owns the option's scope. For example, `automatic-rename`
+belongs to a window: use `Window.SetOption` or `Window.UnsetOption`, then read
+`Window.Options` again for an updated snapshot.
 
-**Set:** `pane.SetOption(ctx, ...)`
+For a single raw value, `Pane.RawOption` returns the string, its presence, and an
+error. Do not treat an error as an absent option.
 
-**Unset:** `pane.UnsetOption(ctx, ...)`
+<!-- /port -->
 
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 **Read all (this scope):** `pane.options()` (typed `BTreeMap`),
 `pane.option_names()`
@@ -63,7 +83,12 @@ declared kind
 
 **Unset:** `pane.unset_option(name)`
 
+<!-- /port -->
+
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
 **Read all (this scope):** `pane.options().all()`
 
@@ -74,7 +99,12 @@ declared kind
 
 **Unset:** `pane.options().unset(name)`
 
+<!-- /port -->
+
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 **Read all (this scope):** `pane.Options.GetAllAsync()`
 
@@ -86,7 +116,12 @@ own `-A`
 
 **Unset:** `pane.Options.UnsetAsync(...)`
 
+<!-- /port -->
+
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
 **Read all (this scope):** `pane->options()`
 
@@ -96,7 +131,12 @@ own `-A`
 
 **Unset:** `pane->unset_option(name)`
 
+<!-- /port -->
+
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 **Read all (this scope):** `server.options(.pane(pane))`
 
@@ -107,10 +147,12 @@ presence from the listing, then the value with `-v`
 
 **Unset:** `server.unsetOption(name, scope: .pane(pane))`
 
+<!-- /port -->
+
 ### Examples
 
 After a successful write completes, read the option to obtain its updated value.
-These examples set, read, and unset a pane option:
+The following examples set, read, and unset an option:
 
 ```python
 pane.set_option("automatic-rename", "off")
@@ -125,9 +167,18 @@ await pane.unsetOption("automatic-rename");
 ```
 
 ```go
-pane.SetOption(ctx, "automatic-rename", "off", tmux.SetOptionOptions{})
-pane.Options(ctx)
-pane.UnsetOption(ctx, "automatic-rename", tmux.UnsetOptionOptions{})
+if err := window.SetOption(ctx, "automatic-rename", "off", tmux.SetOptionOptions{}); err != nil {
+    return fmt.Errorf("set automatic rename: %w", err)
+}
+options, err := window.Options(ctx)
+if err != nil {
+    return fmt.Errorf("read window options: %w", err)
+}
+value, present := options.AutomaticRename().Get()
+fmt.Println("automatic rename:", value, "present:", present)
+if err := window.UnsetOption(ctx, "automatic-rename", tmux.UnsetOptionOptions{}); err != nil {
+    return fmt.Errorf("unset automatic rename: %w", err)
+}
 ```
 
 ```rust
@@ -162,7 +213,10 @@ try await server.unsetOption("automatic-rename", scope: .pane(pane))
 
 ## Hooks
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 **Set:** `pane.set_hook(name, command)`
 
@@ -172,7 +226,12 @@ try await server.unsetOption("automatic-rename", scope: .pane(pane))
 
 **Run now, without the event:** Not listed.
 
+<!-- /port -->
+
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 **Set:** `pane.setHook(name, command, { append })`
 
@@ -182,17 +241,26 @@ try await server.unsetOption("automatic-rename", scope: .pane(pane))
 
 **Run now, without the event:** Not listed.
 
-### Go
+<!-- /port -->
 
-**Set:** `pane.SetHook(ctx, name, command)`, `pane.SetHooks(ctx, ...)` (bulk)
+<!-- port:go -->
+<!-- port:root -->
+### Go
+<!-- /port -->
 
-**Unset:** `pane.UnsetHook(ctx, name)`
+Use `session.SetHook` to register a command and `session.Hooks` to read the
+session's typed hook values. `session.UnsetHook` removes a registration.
+`Session.SetHooks` writes indexed entries when an event needs more than one command.
 
-**List:** `pane.Hooks(ctx)`: typed struct
+Use `server.GlobalSessionScope()` for hooks shared by sessions. Keep hook
+registration at a scope supported by the tmux event.
 
-**Run now, without the event:** Not listed.
+<!-- /port -->
 
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 **Set:** `pane.set_hook(name, command)`
 
@@ -203,7 +271,12 @@ by design (see below)
 
 **Run now, without the event:** Not listed.
 
+<!-- /port -->
+
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
 **Set:** `pane.hooks().set(event, command)`, `.append(event, command)`
 
@@ -213,7 +286,12 @@ by design (see below)
 
 **Run now, without the event:** `pane.hooks().run(event)`: tmux's `set-hook -R`
 
+<!-- /port -->
+
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 **Set:** `pane.Hooks.SetAsync(new SetHookRequest(event, command))`
 
@@ -223,7 +301,12 @@ by design (see below)
 
 **Run now, without the event:** `pane.Hooks.RunAsync(...)`
 
+<!-- /port -->
+
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
 **Set:** `session.set_hook(name, command)`: no `Window`/`Pane` overload exists
 at all
@@ -234,7 +317,12 @@ at all
 
 **Run now, without the event:** Not listed.
 
+<!-- /port -->
+
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 **Set:** `server.setHook(name, to: command, at: index, in: scope)`
 
@@ -244,12 +332,28 @@ at all
 
 **Run now, without the event:** `server.runHook(name, in: scope)`
 
+<!-- /port -->
+
 ### Examples
 
 tmux stores hook commands in indexed arrays, such as `after-new-window[0]`.
-Python and TypeScript can include the index in the name. Go's `SetHooks` and
-Swift's `at:` parameter take it separately. Java's `.append()` and TypeScript's
-`{ append: true }` append without requiring the next index.
+
+<!-- port:py -->
+Include the array index in the hook name.
+<!-- /port -->
+<!-- port:ts -->
+Include the array index in the hook name or pass `{ append: true }` to append.
+<!-- /port -->
+<!-- port:go -->
+`Session.SetHooks` accepts indexed hook entries. Pass a context and check errors from
+both mutations and reads; a successful write does not refresh earlier snapshots.
+<!-- /port -->
+<!-- port:swift -->
+The `at:` parameter selects the array index.
+<!-- /port -->
+<!-- port:java -->
+Use `.append()` to add a command without choosing the next array index.
+<!-- /port -->
 
 Set and list a session hook. The next section explains window and pane scope
 limitations:
@@ -265,8 +369,14 @@ await session.showHooks();
 ```
 
 ```go
-session.SetHook(ctx, "session-renamed", "display-message 'renamed'")
-session.Hooks(ctx)
+if err := session.SetHook(ctx, "session-renamed", "display-message 'renamed'"); err != nil {
+    return fmt.Errorf("set session hook: %w", err)
+}
+value, present, err := session.RawHook(ctx, "session-renamed")
+if err != nil {
+    return fmt.Errorf("read session hooks: %w", err)
+}
+fmt.Println("session-renamed:", value, "present:", present)
 ```
 
 ```rust
@@ -303,23 +413,32 @@ do not imply a separate window or pane hook table, and `show-hooks` does not
 provide a corresponding listing. Check the event's supported scope if a hook is
 accepted but never fires.
 
-Ports handle unsupported hook scopes differently:
+<!-- port:java -->
+Check `hooks().all()` when diagnosing a hook that does not fire. tmux can accept
+a hook at an unsupported scope without an effective registration.
+<!-- /port -->
+
+<!-- port:rs -->
+`Pane::set_hook` and `Window::set_hook` return `Error::OptionScopeMismatch`
+for an unsupported scope.
+<!-- /port -->
 
-- **Java's `Hooks.java`** documents that tmux can accept a hook at an
-  unsupported scope without an effective registration. Check `.all()` when
-  diagnosing a hook that does not fire.
-- **Rust** validates scope in `Pane::set_hook` and `Window::set_hook`, returning
-  `Error::OptionScopeMismatch` for an unsupported scope.
-- **Swift** restricts `HookScope` to `.global` and `.session`. **C++** exposes
-  `set_hook` on `Session` and `global_hooks()` on `Server`, with no window or
-  pane hook methods.
+<!-- port:swift -->
+`HookScope` restricts registration to `.global` and `.session`.
+<!-- /port -->
+
+<!-- port:cxx -->
+Use `Session::set_hook` or `Server::global_hooks()`. Window and pane handles
+do not provide hook methods.
+<!-- /port -->
 
 Options have window and pane tables of their own. The hook-scope limitation does
 not apply to ordinary options.
 
 ## tmux version compatibility
 
-Python's compatibility notes list these tmux requirements:
+<!-- port:py -->
+The compatibility notes list these tmux requirements:
 
 | Feature | Minimum tmux |
 |---------|-------------|
@@ -328,5 +447,16 @@ Python's compatibility notes list these tmux requirements:
 | `client-active`, `window-resized` hooks | 3.3+ |
 | `pane-title-changed` hook | 3.5+ |
 
-Check your port's compatibility notes before relying on a particular tmux
-release.
+<!-- /port -->
+
+Check the library's supported tmux versions before using a version-specific
+option or hook.
+
+<details>
+<summary>tmux manual and source</summary>
+
+The tmux manual defines [option scopes and inherited reads](https://github.com/tmux/tmux/blob/94796f6b1182507efac8a272fc309a79e22e58a5/tmux.1#L4725).
+Unsetting a local value restores inheritance. Hook programs run in tmux when
+their event occurs; see the [hook implementation](https://github.com/tmux/tmux/blob/94796f6b1182507efac8a272fc309a79e22e58a5/cmd-set-option.c).
+
+</details>
diff --git a/site/src/content/docs/topics/pane-interaction.md b/site/src/content/docs/topics/pane-interaction.md
index e3ee7102..055a7452 100644
--- a/site/src/content/docs/topics/pane-interaction.md
+++ b/site/src/content/docs/topics/pane-interaction.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Pane interaction
 description: Input defaults, screen capture, and waiting for a command to finish.
 sidebar:
@@ -11,17 +12,20 @@ tableOfContents: true
 Send input to a pane and capture its screen to interact with a running program.
 [Attach and send keys](/examples/attach-and-send-keys/) provides examples.
 [Sending keys](/guides/sending-keys/) and [Capturing
-output](/guides/capturing-output/) are task guides; this page compares input
+output](/guides/capturing-output/) are task guides; this page covers input
 defaults, capture ranges, and completion handling.
 
 ## Typing into a pane
 
 Two questions come up every time you send something to a pane: should tmux
 press Enter afterward, and should tmux interpret what you sent as key names
-(`Enter`, `C-c`) rather than literal characters? Ports answer both, but
-disagree on whether that's one method with flags or two separate methods:
+(`Enter`, `C-c`) rather than literal characters? Choose both explicitly when
+a command depends on them.
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 **Type without Enter:** `pane.send_keys(text, enter=False)`
 
@@ -29,7 +33,12 @@ disagree on whether that's one method with flags or two separate methods:
 
 **How "literal" is chosen:** `literal=True` flag on the same method
 
+<!-- /port -->
+
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 **Type without Enter:** `pane.sendKeys(text, { enter: false })`
 
@@ -37,7 +46,12 @@ disagree on whether that's one method with flags or two separate methods:
 
 **How "literal" is chosen:** `{ literal: true }` option
 
+<!-- /port -->
+
+<!-- port:go -->
+<!-- port:root -->
 ### Go
+<!-- /port -->
 
 **Type without Enter:** `pane.SendKeys(ctx, SendKeysRequest{Command: &text,
 SkipEnter: true})`
@@ -47,7 +61,12 @@ SkipEnter: true})`
 
 **How "literal" is chosen:** `Literal: true` field
 
+<!-- /port -->
+
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 **Type without Enter:** `pane.send_keys(keys)`: **always literal**, key names
 typed as text
@@ -57,7 +76,12 @@ typed as text
 **How "literal" is chosen:** `send_keys` sends literal text; `send_key_names`
 interprets tmux key names.
 
+<!-- /port -->
+
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
 **Type without Enter:** `pane.send(keys)`
 
@@ -65,26 +89,41 @@ interprets tmux key names.
 
 **How "literal" is chosen:** Separate text and key-sending methods.
 
+<!-- /port -->
+
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 **Type without Enter:** `SendKeysAsync(new SendKeysRequest(text, enter: false))`
 
 **Type + Enter (default):** `SendTextAsync(text)` (defaults `enter: true`)
 
-**How "literal" is chosen:** `Literal` field on `SendKeysRequest`;
+**How "literal" is chosen:** `SendKeysRequest.Literal` field;
 `SendTextAsync` hardcodes it
 
+<!-- /port -->
+
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
 **Type without Enter:** `pane->send_text(text)`
 
-**Type + Enter (default):** `send_text(text)` then `send_key("Enter")`
+**Type + Enter:** `pane->send_text(text)` then `pane->send_key("Enter")`
 separately: no combined convenience exists
 
 **How "literal" is chosen:** `send_text` is always literal; `send_key` is always
 a key name
 
+<!-- /port -->
+
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 **Type without Enter:** `server.sendKeys([text], to: pane)`
 
@@ -93,19 +132,26 @@ a key name
 
 **How "literal" is chosen:** `literally: true` option on `sendKeys`
 
+<!-- /port -->
+
 ### Examples
 
-**Rust's `send_keys` always sends literal text.** Use `send_key_names` for tmux
-key names. Passing `"Enter"` to `send_keys` types those characters; it does not
-press the key.
+<!-- port:rs -->
+`send_keys` sends literal text. Use `send_key_names` for tmux key names.
+Passing `"Enter"` to `send_keys` types those characters. `send_line` appends a
+carriage return and delivers it with the text in one tmux command.
+<!-- /port -->
 
-**Text and Enter can be separate commands.** Python, TypeScript, Go, and .NET
-normally send Enter after the text. If the second operation fails, the text may
-already be in the pane; retrying the entire request can duplicate it. C++'s
-separate `send_text` and `send_key("Enter")` calls have the same risk.
+<!-- port:java -->
+`sendLine` appends a carriage return and delivers it with the text in one tmux
+command.
+<!-- /port -->
 
-Rust's `send_line` and Java's `sendLine` append a literal `\r` to the text and
-send it in one `send-keys -l` command. They avoid a separate Enter dispatch.
+<!-- port:py,ts,go,dotnet,cxx -->
+Text and Enter can be separate tmux commands. If the second operation fails,
+the text may already be in the pane. Check the current state before retrying;
+repeating the whole request can duplicate input.
+<!-- /port -->
 
 Send a command line and press Enter:
 
@@ -120,9 +166,13 @@ await pane.sendKeys("echo hi");
 ```
 
 ```go
-text := "echo hi"
-pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &text, SkipEnter: true})
-pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &text})
+text := "printf 'hello\\n'"
+if err := pane.SendKeys(ctx, tmux.SendKeysRequest{
+    Command: &text,
+    Literal: true,
+}); err != nil {
+    return fmt.Errorf("send command: %w", err)
+}
 ```
 
 ```rust
@@ -152,11 +202,16 @@ try await server.run("echo hi", in: pane)        // sugar for sendKeys([text, "E
 
 ## Reading a pane back
 
-Capture methods return lines from the pane's visible screen by default:
-`pane.capture_pane()` in Python, `pane.capture()` in TypeScript, Rust, Java, and
-C++, `pane.Capture(ctx, ...)` in Go, `CaptureAsync(...)` in .NET, and
-`server.capture(pane)` in Swift. Request scrollback explicitly, such as with
-Python's `start` and `end` or Swift's `includingHistory`.
+Capture reads the pane's visible screen by default. Request scrollback when
+you need earlier output. A capture is a snapshot of terminal contents, including
+any input echoed by the application.
+
+<!-- port:go -->
+`pane.Capture` returns `([]string, error)`. Pass a `context.Context` with a
+deadline and check the error before using the result. Set the start boundary to
+`tmux.CaptureBoundary` to include scrollback. `End: tmux.CaptureBoundary`
+includes the bottom of the visible pane.
+<!-- /port -->
 
 ```python
 pane.capture_pane()
@@ -167,7 +222,13 @@ await pane.capture();
 ```
 
 ```go
-pane.Capture(ctx, tmux.CapturePaneRequest{}) // the zero value: visible screen
+lines, err := pane.Capture(ctx, tmux.CapturePaneRequest{})
+if err != nil {
+    return fmt.Errorf("capture pane: %w", err)
+}
+for _, line := range lines {
+    fmt.Println(line)
+}
 ```
 
 ```rust
@@ -193,19 +254,43 @@ try await server.capture(pane)
 ## Waiting for something to finish
 
 A send call completes when input reaches tmux. It does not wait for the shell
-command to finish. Wait for expected output or a completion signal:
-
-- **Python** can poll capture output for a marker. Its test-support module also
-  provides `libtmux.test.retry_until(condition, ...)` for arbitrary conditions.
-  [Waiting and retrying](../waiting-and-retry/) covers polling helpers across
-  ports.
-- **Swift** ships a real primitive for exactly this:
-  `server.waitForOutput(...)` returns an `OutputWait` once a pattern shows
-  up in the pane, rather than leaving you to write the loop.
-- **Go** and **.NET** expose tmux's `wait-for` signal channel through
-  `server.WaitFor(ctx, WaitForRequest{...})` and `TmuxWaitChannel`. Use a named
-  signal when you control the command and can make it announce completion.
-
-[Capture pane output](/examples/capture-pane-output/) has the checked,
-per-port code for the polling-with-a-marker version of this; reach for a
-port's native wait primitive above it where one exists.
+command to finish. Wait for expected output or a completion signal.
+
+<!-- port:py -->
+Poll capture output for a marker or use the `wait_for` signal channel when you
+control the command. The test-support module provides
+`libtmux.test.retry_until(condition, ...)` for arbitrary conditions.
+<!-- /port -->
+
+<!-- port:swift -->
+`server.waitForOutput(...)` waits for a pattern in pane output and returns an
+`OutputWait`. Give the wait a timeout.
+<!-- /port -->
+
+<!-- port:go -->
+Use `server.WaitFor` with a `WaitForRequest` when the command can signal tmux's
+`wait-for` channel. For streaming output, open `pane.OpenObservation(ctx)`
+before sending input so the observation includes the command's first bytes.
+Both paths take a context; cancellation bounds how long the caller waits.
+
+For a new command whose exit status matters, use `session.Run` and inspect its
+result. Capturing screen text alone cannot establish the command's exit status.
+<!-- /port -->
+
+<!-- port:dotnet -->
+Use `TmuxWaitChannel` when the command can signal a named tmux `wait-for`
+channel. Use a cancellation token to bound the wait.
+<!-- /port -->
+
+[Capture pane output](/examples/capture-pane-output/) shows capture and waiting
+examples. [Waiting and retrying](../waiting-and-retry/) explains completion
+conditions and timeouts.
+
+<details>
+<summary>tmux manual and source</summary>
+
+The tmux manual defines [key-name and literal input](https://github.com/tmux/tmux/blob/94796f6b1182507efac8a272fc309a79e22e58a5/tmux.1#L4457)
+and [screen and history capture](https://github.com/tmux/tmux/blob/94796f6b1182507efac8a272fc309a79e22e58a5/tmux.1#L2798).
+A send operation delivers input; it does not establish the program's exit status.
+
+</details>
diff --git a/site/src/content/docs/topics/socket-and-servers.md b/site/src/content/docs/topics/socket-and-servers.md
index faf5fa76..e9a753cb 100644
--- a/site/src/content/docs/topics/socket-and-servers.md
+++ b/site/src/content/docs/topics/socket-and-servers.md
@@ -1,6 +1,7 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Socket and servers
-description: How a port names one specific tmux server among several, checks whether it's actually there, and tells one running instance apart from another.
+description: Select a server socket, check liveness, and detect a replacement daemon.
 sidebar:
   label: Socket and servers
   group: Topics
@@ -17,15 +18,15 @@ selectors:
 
 | Port | Default | Named socket (`-L`) | Explicit path (`-S`) |
 |------|---------|----------------------|------------------------|
-| Python | `Server()` | `Server(socket_name="work")` | `Server(socket_path="/tmp/tmux-1000/work")` |
-| TypeScript | `new Server()` | `new Server({ socketName: "work" })` | `new Server({ socketPath: "..." })` |
-| Go | `tmux.NewServer(tmux.ServerOptions{})` | `tmux.ServerOptions{SocketName: "work"}` | `tmux.ServerOptions{SocketPath: "..."}` |
-| Rust | `Server::new()` | `Server::builder().socket_name("work").build()?` | `Server::builder().socket_path("...").build()?` |
-| Java | `ServerEndpoint.defaultSocket()` | `ServerEndpoint.namedSocket("work")` | `ServerEndpoint.socketPath(path)` |
-| .NET | `new ServerConnectionOptions()` | `new ServerConnectionOptions(socketName: "work")` | `new ServerConnectionOptions(socketPath: "...")` |
-| C++ | `Server::at_default()` | `Server::at_socket_name("work")` | `Server::at_socket_path("...")` |
-| Swift | no bare default: see below | `Server(socketName: "work")` | `Server(socketPath: "...")` |
-
+<!-- port:py -->| Python | `Server()` | `Server(socket_name="work")` | `Server(socket_path="/tmp/tmux-1000/work")` |
+<!-- /port --><!-- port:ts -->| TypeScript | `new Server()` | `new Server({ socketName: "work" })` | `new Server({ socketPath: "..." })` |
+<!-- /port --><!-- port:go -->| Go | `tmux.NewServer(tmux.ServerOptions{})` | `tmux.ServerOptions{SocketName: "work"}` | `tmux.ServerOptions{SocketPath: "..."}` |
+<!-- /port --><!-- port:rs -->| Rust | `Server::new()` | `Server::builder().socket_name("work").build()?` | `Server::builder().socket_path("...").build()?` |
+<!-- /port --><!-- port:java -->| Java | `ServerEndpoint.defaultSocket()` | `ServerEndpoint.namedSocket("work")` | `ServerEndpoint.socketPath(path)` |
+<!-- /port --><!-- port:dotnet -->| .NET | `new ServerConnectionOptions()` | `new ServerConnectionOptions(socketName: "work")` | `new ServerConnectionOptions(socketPath: "...")` |
+<!-- /port --><!-- port:cxx -->| C++ | `Server::at_default()` | `Server::at_socket_name("work")` | `Server::at_socket_path("...")` |
+<!-- /port --><!-- port:swift -->| Swift | no bare default: see below | `Server(socketName: "work")` | `Server(socketPath: "...")` |
+<!-- /port -->
 ```python
 default_server = libtmux.Server()
 named = libtmux.Server(socket_name="work")
@@ -37,6 +38,9 @@ const named = new Server({ socketName: "work" });
 
 ```go
 named, err := tmux.NewServer(tmux.ServerOptions{SocketName: "work"})
+if err != nil {
+    return err
+}
 ```
 
 ```rust
@@ -64,16 +68,29 @@ auto named = libtmux::Server::at_socket_name("work");
 let named = try Server(socketName: "work")
 ```
 
-Choose either a socket name or a socket path. TypeScript rejects both together
-with `TypeError`; Go documents that `SocketPath` takes precedence. tmux uses
-`TMUX_TMPDIR` to resolve the directory for default and named sockets.
+Choose either a socket name or a socket path. tmux uses `TMUX_TMPDIR` to
+resolve the directory for default and named sockets.
+
+<!-- port:ts -->
+Supplying both selectors raises `TypeError`.
+<!-- /port -->
+<!-- port:go -->
+`ServerOptions.SocketPath` takes precedence over `ServerOptions.SocketName` when both are set.
+<!-- /port -->
 
+<!-- port:swift -->
 Swift requires an explicit `socketPath` or `socketName` argument. To reach
 tmux's default socket, use `Server(socketName: "default")`.
-
-Python's `Server(socket_name_factory=...)` and .NET's
-`ServerConnectionOptions(socketNameFactory: ...)` accept a callable that
+<!-- /port -->
+
+<!-- port:py -->
+`Server(socket_name_factory=...)` accepts a callable that generates socket
+names. Use a unique name for each isolated test server.
+<!-- /port -->
+<!-- port:dotnet -->
+`ServerConnectionOptions(socketNameFactory: ...)` accepts a callable that
 generates socket names. Use a unique name for each isolated test server.
+<!-- /port -->
 
 ## Is the server actually there?
 
@@ -83,15 +100,15 @@ socket:
 
 | Port | Check |
 |------|-------|
-| Python | `server.is_alive()` → `bool` |
-| TypeScript | `await server.isAlive()` → `Promise<boolean>`; `await server.raiseIfDead()` throws with tmux's own reason instead |
-| Go | `server.IsAlive(ctx)` → `(bool, error)`: the `error` is reserved for a question that couldn't be answered at all, not for "not alive" |
-| Rust | `server.is_alive().await` → `bool`; `server.check_alive().await` is the fallible twin, for when the *reason* matters |
-| Java | `server.isAlive()` → `boolean` |
-| .NET | `await server.IsAliveAsync()` → `Task<bool>` |
-| C++ | `server.is_alive(timeout)` → `bool` |
-| Swift | `try await server.isRunning()` → `Bool` |
-
+<!-- port:py -->| Python | `server.is_alive()` → `bool` |
+<!-- /port --><!-- port:ts -->| TypeScript | `await server.isAlive()` → `Promise<boolean>`; `await server.raiseIfDead()` throws with tmux's own reason instead |
+<!-- /port --><!-- port:go -->| Go | `server.IsAlive(ctx)` → `(bool, error)`: the `error` is reserved for a question that couldn't be answered at all, not for "not alive" |
+<!-- /port --><!-- port:rs -->| Rust | `server.is_alive().await` → `bool`; `server.check_alive().await` is the fallible twin, for when the *reason* matters |
+<!-- /port --><!-- port:java -->| Java | `server.isAlive()` → `boolean` |
+<!-- /port --><!-- port:dotnet -->| .NET | `await server.IsAliveAsync()` → `Task<bool>` |
+<!-- /port --><!-- port:cxx -->| C++ | `server.is_alive(timeout)` → `bool` |
+<!-- /port --><!-- port:swift -->| Swift | `try await server.isRunning()` → `Bool` |
+<!-- /port -->
 ```python
 if server.is_alive():
     server.sessions
@@ -105,6 +122,10 @@ if (await server.isAlive()) {
 
 ```go
 alive, err := server.IsAlive(ctx)
+if err != nil {
+    return err
+}
+fmt.Println("server running:", alive)
 ```
 
 ```rust
@@ -138,24 +159,48 @@ if try await server.isRunning() {
 }
 ```
 
-TypeScript's `isAlive()` and Rust's `is_alive()` return a boolean. Use
-TypeScript's `raiseIfDead()` or Rust's `check_alive()` when you need failure
-details.
+<!-- port:ts -->
+`isAlive()` returns a boolean. Use `raiseIfDead()` when you need failure details.
+<!-- /port -->
+<!-- port:rs -->
+`is_alive()` returns a boolean. Use `check_alive()` when you need failure details.
+<!-- /port -->
 
 ## Killing a server, and telling two apart
 
-Kill an entire server with Python's `server.kill_server()`, TypeScript's `await
-server.kill()`, Go's `server.Kill(ctx)`, Rust's `server.kill().await?`, Java's
-or Swift's `server.killServer()`, .NET's `await server.KillAsync()`, or C++'s
-`server.kill()`. Java's `Server.close()` only releases the local connection; see
-[Context
-managers](../context-managers/#java-server-is-closeable-but-closing-one-doesnt-kill-it).
-
-Two handles can select the same socket. Python's `Server.__eq__` compares
-`socket_name` and `socket_path`. Go's `server.Equal(other)` resolves relative
-paths and environment-dependent socket names against each handle's captured
-binding.
-
-A restarted server can reuse a socket path while having different state.
-TypeScript's `TmuxServerRestartedError` and Go's `ErrDaemonReplaced` detect a handle
-encountering a replacement daemon.
+Killing a server ends all its sessions. Use this only for a server your program
+owns; for narrower cleanup, kill the session or pane you created.
+
+<!-- port:py -->
+Call `server.kill_server()`. `Server.__eq__` compares `socket_name` and
+`socket_path` when deciding whether two handles select the same endpoint.
+<!-- /port -->
+<!-- port:ts -->
+Call `await server.kill()`. `TmuxServerRestartedError` reports an operation
+whose handle encountered a replacement daemon on the same socket.
+<!-- /port -->
+<!-- port:go -->
+Call `server.Kill(ctx)` and check its error. `server.Equal(other)` compares
+the captured socket bindings, resolving relative paths and environment-based
+socket names. Equal endpoints do not prove equal daemon lifetimes.
+`ErrDaemonReplaced` reports a replacement daemon on the selected socket.
+<!-- /port -->
+<!-- port:rs -->
+Call `server.kill().await?` and handle a cleanup failure before returning.
+<!-- /port -->
+<!-- port:java -->
+Call `server.killServer()` to stop tmux. `Server.close()` releases the local
+connection and leaves tmux running; see [Ownership and cleanup](../context-managers/).
+<!-- /port -->
+<!-- port:dotnet -->
+Call `await server.KillAsync()` and handle a cleanup failure before returning.
+<!-- /port -->
+<!-- port:cxx -->
+Call `server.kill()` and inspect its result for a failure.
+<!-- /port -->
+<!-- port:swift -->
+Call `try await server.killServer()` and handle a cleanup failure before returning.
+<!-- /port -->
+
+A restarted server can reuse a socket path while having different state. Do
+not treat a matching path as proof that a cached object still exists.
diff --git a/site/src/content/docs/topics/traversal.md b/site/src/content/docs/topics/traversal.md
index 554763b1..4125ab41 100644
--- a/site/src/content/docs/topics/traversal.md
+++ b/site/src/content/docs/topics/traversal.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Traversal
 description: Moving up and down the server/session/window/pane tree, and the two questions that come up once you have more than one object.
 sidebar:
@@ -22,18 +23,22 @@ pane](/concepts/server-session-window-pane/).
 
 | Port | Server → sessions | Session → windows | Window → panes |
 |------|--------------------|--------------------|-----------------|
-| Python | `server.sessions` | `session.windows` | `window.panes` |
-| TypeScript | `await server.sessions()` | `session.windows` | `window.panes` |
-| Go | `server.Sessions(ctx)` | `session.Windows()` | `window.Panes()` |
-| Rust | `await server.sessions()` | `session.windows()` | `window.panes()` |
-| Java | `server.sessions()` | `session.windows()` | `window.panes()` |
-| .NET | `server.GetSessionsAsync()` | `session.GetWindowsAsync()` | `window.GetPanesAsync()` |
-| C++ | `server->sessions()` | `session->windows()` | `window->panes()` |
-| Swift | `server.sessions()`, or `snapshot.windows(of: session)` for windows/panes once you have a `Snapshot` | see previous column | see previous column |
-
-TypeScript's `session.windows` and `window.panes` read the graph loaded by
-`await server.sessions()` without additional tmux commands. Rust also provides
-`server.attached_sessions()` to list only sessions with an attached client.
+<!-- port:py -->| Python | `server.sessions` | `session.windows` | `window.panes` |
+<!-- /port --><!-- port:ts -->| TypeScript | `await server.sessions()` | `session.windows` | `window.panes` |
+<!-- /port --><!-- port:go -->| Go | `server.Sessions(ctx)` | `session.Windows()` | `window.Panes()` |
+<!-- /port --><!-- port:rs -->| Rust | `await server.sessions()` | `session.windows()` | `window.panes()` |
+<!-- /port --><!-- port:java -->| Java | `server.sessions()` | `session.windows()` | `window.panes()` |
+<!-- /port --><!-- port:dotnet -->| .NET | `server.GetSessionsAsync()` | `session.GetWindowsAsync()` | `window.GetPanesAsync()` |
+<!-- /port --><!-- port:cxx -->| C++ | `server->sessions()` | `session->windows()` | `window->panes()` |
+<!-- /port --><!-- port:swift -->| Swift | `Server.sessions()`, or `snapshot.windows(of: session)` for windows/panes once you have a `Snapshot` | see previous column | see previous column |
+<!-- /port -->
+<!-- port:ts -->
+`session.windows` and `window.panes` read the graph loaded by
+`await server.sessions()` without additional tmux commands.
+<!-- /port -->
+<!-- port:rs -->
+`server.attached_sessions()` lists only sessions with an attached client.
+<!-- /port -->
 
 ## All panes in a session
 
@@ -42,48 +47,80 @@ as finding a command or capturing output from every pane. A window linked to
 multiple sessions still refers to the same tmux panes. Check whether the API
 reads live state or traverses a captured graph before reusing its result.
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 `libtmux.Session.panes` runs a session-scoped `list-panes -s` read. Use it to
 list panes across the session's windows without manually listing each window.
+<!-- /port -->
 
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 `session.Session.panes` returns a `Selection` from the session's captured
 graph. Reading it does not issue another tmux command; refresh the snapshot
 when you need newer state.
+<!-- /port -->
 
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 `session.Session.panes` performs a live listing and returns a `Result` from
 the async call. Handle a command failure before using the returned panes.
+<!-- /port -->
 
+<!-- port:go -->
+<!-- port:root -->
 ### Go
+<!-- /port -->
 
 `tmux.Session.Panes` reads captured relations without another tmux command.
 The relation must have been included in the read that produced the session;
 an uncaptured relation does not establish that the session has no panes.
+<!-- /port -->
 
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 `LibTmux.Session.Panes` reads the session's captured relations. It does not
 issue a tmux command; an incomplete capture may lack the required relation.
+<!-- /port -->
 
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
 `libtmux::Session::panes` runs a session-scoped `list-panes` command. Inspect
 the returned result before traversing the panes.
+<!-- /port -->
 
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 `Snapshot.panes(of:)` accepts a session or a window. The session overload
 traverses the captured graph and deduplicates pane IDs without a tmux read.
+<!-- /port -->
 
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
 Java has no direct session-wide pane member. Traverse `Session.windows()`
 and then `Window.panes()` in the captured relations. Deduplicate pane IDs
 when combining results from sessions that may share linked windows.
+<!-- /port -->
 
 ## Up the hierarchy
 
@@ -93,23 +130,33 @@ pane](/concepts/server-session-window-pane/) introduces that distinction:
 
 | Port | Pane → window | Window → session |
 |------|----------------|--------------------|
-| Python | `pane.window` | `window.session` |
-| TypeScript | `pane.window` (getter, from the loaded graph) | `window.session` (getter) |
-| Go | `pane.Window()` → `(Window, bool)` | `window.Session()` → `(Session, bool)` |
-| Rust | `await pane.window()` → `Result<Option<Window>, Error>` | `await window.session()` → `Result<Option<Session>, Error>` |
-| Java | `pane.window()` | `window.session()` |
-| .NET | `pane.Window` (property) | `window.Session` (property) |
-| C++ | `pane->window()` | `window->session()` |
-| Swift | `pane.windowID`, then look it up via `Snapshot` | not a per-window field: join through the snapshot instead |
-
-Go and Rust return optional relationship results. .NET's `.Window`, `.Session`,
-`.ActiveWindow`, and `.ActivePane` read captured state synchronously and throw
-`IncompleteSnapshotException` if that capture lacks the required context.
+<!-- port:py -->| Python | `pane.window` | `window.session` |
+<!-- /port --><!-- port:ts -->| TypeScript | `pane.window` (getter, from the loaded graph) | `window.session` (getter) |
+<!-- /port --><!-- port:go -->| Go | `pane.Window()` → `(Window, bool)` | `window.Session()` → `(Session, bool)` |
+<!-- /port --><!-- port:rs -->| Rust | `await pane.window()` → `Result<Option<Window>, Error>` | `await window.session()` → `Result<Option<Session>, Error>` |
+<!-- /port --><!-- port:java -->| Java | `pane.window()` | `window.session()` |
+<!-- /port --><!-- port:dotnet -->| .NET | `pane.Window` (property) | `window.Session` (property) |
+<!-- /port --><!-- port:cxx -->| C++ | `pane->window()` | `window->session()` |
+<!-- /port --><!-- port:swift -->| Swift | `pane.windowID`, then look it up via `Snapshot` | not a per-window field: join through the snapshot instead |
+<!-- /port -->
+<!-- port:go -->
+Check the boolean from a relationship lookup. It reports whether the relation
+was captured, not whether the object still exists in tmux. Use a live read when
+current existence matters.
+<!-- /port -->
+<!-- port:rs -->
+Handle both a command failure and an absent parent in the optional result.
+<!-- /port -->
+<!-- port:dotnet -->
+`.Window`, `.Session`, `.ActiveWindow`, and `.ActivePane` read captured state
+synchronously. They throw `IncompleteSnapshotException` when the capture lacks
+the required context.
+<!-- /port -->
 
 ## One walk, down and back up
 
-Start with a session, traverse to a window and pane, then look up the parent and
-compare its identity with the starting object:
+List a session's windows, then look up a parent and compare its identity with
+the starting object:
 
 ```python
 session = server.sessions[0]
@@ -131,12 +178,22 @@ window.session.id === session.id;
 
 ```go
 sessions, err := server.Sessions(ctx)
-session := sessions[0]
-windows, err := session.Windows()
-window := windows[0]
-
-back, ok := window.Session() // ok is false if the window outlived it
-back.ID() == session.ID()
+if err != nil {
+    return err
+}
+for _, session := range sessions {
+    windows, captured := session.Windows()
+    if !captured {
+        return fmt.Errorf("session %s has no captured window relations", session.ID())
+    }
+    for _, window := range windows {
+        back, captured := window.Session()
+        if !captured {
+            return fmt.Errorf("window %s has no captured session", window.ID())
+        }
+        fmt.Println(window.ID(), "belongs to session:", back.ID() == session.ID())
+    }
+}
 ```
 
 ```rust
@@ -196,19 +253,20 @@ active child directly rather than making you filter a list:
 
 | Port | Session's active window | Window's active pane |
 |------|---------------------------|------------------------|
-| Python | `session.active_window` | `window.active_pane` |
-| TypeScript | `session.activeWindow` (getter) | `window.activePane` (getter) |
-| Go | `session.ActiveWindow()` → `(Window, bool)` | `window.ActivePane()` → `(Pane, bool)` |
-| Rust | `await session.active_window()` → `Result<Option<Window>, Error>` | `await window.active_pane()` → `Result<Option<Pane>, Error>` |
-| Java | `session.activeWindow()` → `Optional<Window>` | `window.activePane()` → `Optional<Pane>` |
-| .NET | `session.ActiveWindow` (property) | `window.ActivePane` (property) |
-| C++ | `session->active_window()` | `window->active_pane()` |
-| Swift | filter for `isActive` on `snapshot.windows(of: session)`: `Window` carries its own `window_active` flag rather than the session exposing an accessor | same pattern, on the pane's own active flag |
-
-In Swift, filter snapshot children by `isActive`. Other ports expose an
-active-child method or property on the parent. [Format-token
-fields](../format-tokens/) describes the underlying `window_active` and
-`pane_active` fields.
+<!-- port:py -->| Python | `session.active_window` | `window.active_pane` |
+<!-- /port --><!-- port:ts -->| TypeScript | `session.activeWindow` (getter) | `window.activePane` (getter) |
+<!-- /port --><!-- port:go -->| Go | `session.ActiveWindow()` → `(Window, bool)` | `window.ActivePane()` → `(Pane, bool)` |
+<!-- /port --><!-- port:rs -->| Rust | `await session.active_window()` → `Result<Option<Window>, Error>` | `await window.active_pane()` → `Result<Option<Pane>, Error>` |
+<!-- /port --><!-- port:java -->| Java | `session.activeWindow()` → `Optional<Window>` | `window.activePane()` → `Optional<Pane>` |
+<!-- /port --><!-- port:dotnet -->| .NET | `session.ActiveWindow` (property) | `window.ActivePane` (property) |
+<!-- /port --><!-- port:cxx -->| C++ | `session->active_window()` | `window->active_pane()` |
+<!-- /port --><!-- port:swift -->| Swift | filter for `isActive` on `snapshot.windows(of: session)`: `Window` carries its own `window_active` flag rather than the session exposing an accessor | same pattern, on the pane's own active flag |
+<!-- /port -->
+<!-- port:swift -->
+Filter snapshot children by `isActive`.
+<!-- /port -->
+[Format-token fields](../format-tokens/) describes the underlying
+`window_active` and `pane_active` fields.
 
 ## Is it in that collection?
 
@@ -216,16 +274,30 @@ Checking membership generally goes through whatever your language uses for
 collection membership, since most of these calls already return an ordinary
 array, slice, or list:
 
-- **Python** overloads `in` directly on its `QueryList`: `window in
-  session.windows`, `pane in window.panes`.
-- **Java**, **C++**, and **.NET** return standard collections. Use their
-  standard membership operations with the identity comparison appropriate to the
-  port.
-- **TypeScript** returns iterable `Selection<T>` objects. Iterate over the
-  selection and compare IDs, or spread it into an array for standard array
-  operations.
-- **Go** and **Rust** return slices or vectors. Iterate and compare object IDs
-  when testing membership by tmux identity.
+<!-- port:py -->
+`QueryList` supports `in`: use `window in session.windows` or
+`pane in window.panes`.
+<!-- /port -->
+<!-- port:java,cxx,dotnet -->
+Use standard collection membership operations with the object identity
+comparison described below.
+<!-- /port -->
+<!-- port:ts -->
+`Selection<T>` is iterable. Iterate and compare IDs, or spread it into an array
+for standard array operations.
+<!-- /port -->
+<!-- port:go -->
+Iterate over the slice and compare each object's stable ID, such as `Pane.ID()`.
+Confirm the objects belong to the same server before comparing IDs.
+<!-- /port -->
+<!-- port:rs -->
+Iterate over the vector and compare each object's `id()`. Confirm the objects
+belong to the same server before comparing IDs.
+<!-- /port -->
+<!-- port:swift -->
+Use the collection's `contains(where:)` to compare IDs. Confirm the objects
+belong to the same server before comparing IDs.
+<!-- /port -->
 
 ## Is this the same object?
 
@@ -234,17 +306,19 @@ the same server. Equality operators vary by port:
 
 | Port | How you check |
 |------|----------------|
-| Python | `window.window_id == other.window_id` (or `pane.pane_id == ...`) |
-| TypeScript | compare `.id` |
-| Go | `pane.ID() == other.ID()`: `PaneID` is a plain, `==`-comparable `string` |
-| Rust | `pane.id() == other.id()`: verified from the port's own doctests, not struct equality |
-| Java | `pane.equals(other)`: overridden to compare server identity plus pane ID |
-| .NET | `pane.Equals(other)`: overridden to compare a generation counter plus ID |
-| C++ | `pane == other`: `operator==` is defined directly on `Session`/`Window`/`Pane` |
-| Swift | compare `.id` for identity; see the equality note below |
-
+<!-- port:py -->| Python | `window.window_id == other.window_id` (or `pane.pane_id == ...`) |
+<!-- /port --><!-- port:ts -->| TypeScript | compare `.id` |
+<!-- /port --><!-- port:go -->| Go | `pane.ID() == other.ID()`: `PaneID` is a plain, `==`-comparable `string` |
+<!-- /port --><!-- port:rs -->| Rust | `pane.id() == other.id()`: verified from the port's own doctests, not struct equality |
+<!-- /port --><!-- port:java -->| Java | `pane.equals(other)`: overridden to compare server identity plus pane ID |
+<!-- /port --><!-- port:dotnet -->| .NET | `pane.Equals(other)`: overridden to compare a generation counter plus ID |
+<!-- /port --><!-- port:cxx -->| C++ | `pane == other`: `operator==` is defined directly on `Session`/`Window`/`Pane` |
+<!-- /port --><!-- port:swift -->| Swift | compare `.id` for identity; see the equality note below |
+<!-- /port -->
+<!-- port:swift -->
 **Swift's equality compares captured state.** Compiler-synthesized equality for
 `Session`, `Window`, and `Pane` compares every stored property, including
 dimensions and current command. Two reads can compare unequal even when they
 describe the same tmux object. Compare `.id` when checking identity on the same
 server.
+<!-- /port -->
diff --git a/site/src/content/docs/topics/waiting-and-retry.md b/site/src/content/docs/topics/waiting-and-retry.md
index f01da13d..22ec68c0 100644
--- a/site/src/content/docs/topics/waiting-and-retry.md
+++ b/site/src/content/docs/topics/waiting-and-retry.md
@@ -1,4 +1,5 @@
 ---
+supportedPorts: [py, ts, rs, go, java, dotnet, cxx, swift]
 title: Waiting and retrying
 description: Polling a condition instead of guessing a sleep, and tmux's own wait-for signal channel as the alternative to polling.
 sidebar:
@@ -17,72 +18,108 @@ waiting for screen text. This page covers arbitrary conditions and tmux's named
 ## Polling a condition
 
 Polling checks a condition repeatedly until it succeeds or a deadline expires.
-The helpers below expose an interval and timeout; several live in test-support
-packages:
+Set a deadline and choose an interval that limits unnecessary tmux commands.
 
+<!-- port:py -->
+<!-- port:root -->
 ### Python
+<!-- /port -->
 
 **Helper:** `libtmux.test.retry_until(fn, seconds=, interval=)`
 
-**Where it lives:** The `libtmux.test` module in the main package; raises
+**Where it lives:** `src/libtmux/test/` in the main package; raises
 `WaitTimeout`.
+<!-- /port -->
 
+<!-- port:ts -->
+<!-- port:root -->
 ### TypeScript
+<!-- /port -->
 
 **Helper:** `connectedServer.waitFor(matches, options)`
 
 **Where it lives:** The public control-connection API. Tests a predicate over
 `ServerSnapshot`; see [Control mode vs one-shot](/concepts/transports/).
+<!-- /port -->
 
+<!-- port:go -->
+<!-- port:root -->
 ### Go
+<!-- /port -->
 
 **Helper:** `tmuxtest.WaitFor(ctx, interval, condition)`
 
 **Where it lives:** `tmuxtest`, a separate test-support package from `tmux`
+<!-- /port -->
 
+<!-- port:rs -->
+<!-- port:root -->
 ### Rust
+<!-- /port -->
 
 **Helper:** `libtmux::test::retry_until(within, condition)`
 
-**Where it lives:** `libtmux::test`, enabled with the `test-support` Cargo
+**Where it lives:** `crates/libtmux/src/test.rs`, enabled with the `test-support` Cargo
 feature.
+<!-- /port -->
 
+<!-- port:java -->
+<!-- port:root -->
 ### Java
+<!-- /port -->
 
 **Helper:** Not listed.
 
 **Where it lives:** not found in the shipped library; a package-private
 `Await.until(...)` exists only inside the `integration-tests` module, which
 downstream code cannot depend on
+<!-- /port -->
 
+<!-- port:dotnet -->
+<!-- port:root -->
 ### .NET
+<!-- /port -->
 
 **Helper:** `LibTmux.Testing.TmuxWait.UntilAsync(probe, timeout, interval)`
 
-**Where it lives:** `LibTmux.Testing`, part of the same shipped `LibTmux`
-package
+**Where it lives:** the separate `LibTmux.Testing` package
+<!-- /port -->
 
+<!-- port:cxx -->
+<!-- port:root -->
 ### C++
+<!-- /port -->
 
 **Helper:** Not listed.
 
 **Where it lives:** no generic condition-poll helper found in the public
 library; a `wait_until` exists only in the private `testing` component, for
 waiting on a spawned child process, not on tmux state
+<!-- /port -->
 
+<!-- port:swift -->
+<!-- port:root -->
 ### Swift
+<!-- /port -->
 
 **Helper:** Not listed.
 
 **Where it lives:** a `waitUntil` helper exists only inside the test target's
 own support code, not shipped
+<!-- /port -->
 
 ### Examples
 
-Python, Rust, Go, and .NET provide general polling helpers in their test-support
-APIs. TypeScript's public `waitFor` instead waits on a server-snapshot predicate
-through a control connection. It subscribes before reading so it does not miss a
+<!-- port:ts -->
+`waitFor` subscribes before reading a server snapshot so it does not miss a
 change between those steps.
+<!-- /port -->
+<!-- port:go -->
+`tmuxtest.WaitFor` probes immediately, then at the requested positive interval.
+It returns a probe error or context error unchanged. Each probe must read fresh
+state and honor its context. `Session.Windows()` only reads a stored snapshot;
+use `Session.SearchWindows` to query tmux on every probe.
+<!-- /port -->
 
 ```python
 def is_window_up(pane, name):
@@ -92,13 +129,15 @@ libtmux.test.retry_until(lambda: is_window_up(pane, "build"), seconds=5.0)
 ```
 
 ```typescript
-const live = await server.connect();
+await using live = await server.connect();
 await live.waitFor((snapshot) => snapshot.windows.exists({ name: "build" }));
 ```
 
 ```go
-err := tmuxtest.WaitFor(ctx, 50*time.Millisecond, func(ctx context.Context) (bool, error) {
-	windows, err := session.Windows()
+waitCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+defer cancel()
+err := tmuxtest.WaitFor(waitCtx, 50*time.Millisecond, func(ctx context.Context) (bool, error) {
+	windows, err := session.SearchWindows(ctx, nil)
 	if err != nil {
 		return false, err
 	}
@@ -109,6 +148,9 @@ err := tmuxtest.WaitFor(ctx, 50*time.Millisecond, func(ctx context.Context) (boo
 	}
 	return false, nil
 })
+if err != nil {
+    return fmt.Errorf("wait for build window: %w", err)
+}
 ```
 
 ```rust
@@ -125,11 +167,11 @@ await LibTmux.Testing.TmuxWait.UntilAsync(
     TimeSpan.FromMilliseconds(50));
 ```
 
-For Java, C++, and Swift, this page lists no public arbitrary-condition polling
-helper. Use a loop with a deadline and interval if a more specific wait API does
-not fit; [Pane
-interaction](../pane-interaction/#waiting-for-something-to-finish) covers output
-waits.
+<!-- port:java,cxx,swift -->
+Use a loop with a deadline and interval when a specific wait API does not fit.
+[Pane interaction](../pane-interaction/#waiting-for-something-to-finish)
+covers output waits.
+<!-- /port -->
 
 ## tmux's own wait-for channel
 
@@ -139,15 +181,15 @@ announce its own completion:
 
 | Port | Signal | Wait |
 |------|--------|------|
-| Python | `server.wait_for(channel, set_flag=True)` | `server.wait_for(channel)` |
-| TypeScript | not exposed as public API: used only inside the test-server's own startup handshake | - |
-| Go | `server.WaitFor(ctx, tmux.WaitForRequest{Channel: name, Mode: tmux.WaitForModeSignal})` | `tmux.WaitForRequest{Channel: name}` (the zero-value `WaitForRequest.Mode` waits) |
-| Rust | `server.signal_channel(name).await?` | `server.wait_for_channel(name, timeout).await?` → `ChannelWait::Signalled` or `TimedOut` |
-| Java | `server.channel(name).signal()` | `server.channel(name).await(timeout)` → a `WakeReason`, never silently "success" |
-| .NET | `server.OpenWaitChannel(name)` returns a `TmuxWaitChannel`; signalling is the same request with a different mode | `await using` the channel, then `WaitAsync(budget)` |
-| C++ | `server.signal(channel)` | `server.wait_for(channel, timeout)` |
-| Swift | `try await server.signal(channel)` | `try await server.wait(for: channel)` |
-
+<!-- port:py -->| Python | `server.wait_for(channel, set_flag=True)` | `server.wait_for(channel)` |
+<!-- /port --><!-- port:ts -->| TypeScript | not exposed as public API: used only inside the test-server's own startup handshake | - |
+<!-- /port --><!-- port:go -->| Go | `server.WaitFor(ctx, tmux.WaitForRequest{Channel: name, Mode: tmux.WaitForModeSignal})` | `tmux.WaitForRequest{Channel: name}` (the zero-value `WaitForRequest.Mode` waits) |
+<!-- /port --><!-- port:rs -->| Rust | `server.signal_channel(name).await?` | `server.wait_for_channel(name, timeout).await?` → `ChannelWait::Signalled` or `TimedOut` |
+<!-- /port --><!-- port:java -->| Java | `server.channel(name).signal()` | `server.channel(name).await(timeout)` → a `WakeReason`, never silently "success" |
+<!-- /port --><!-- port:dotnet -->| .NET | `server.OpenWaitChannel(name)` returns a `TmuxWaitChannel`; signalling is the same request with a different mode | `await using` the channel, then `WaitAsync(budget)` |
+<!-- /port --><!-- port:cxx -->| C++ | `server.signal(channel)` | `server.wait_for(channel, timeout)` |
+<!-- /port --><!-- port:swift -->| Swift | `try await server.signal(channel)` | `try await server.wait(for: channel)` |
+<!-- /port -->
 ```python
 server.new_session(session_name="work")
 server.wait_for("built", set_flag=True)  # signal
@@ -155,8 +197,14 @@ server.wait_for("built")                 # block until signalled
 ```
 
 ```go
-server.WaitFor(ctx, tmux.WaitForRequest{Channel: "built", Mode: tmux.WaitForModeSignal})
-server.WaitFor(ctx, tmux.WaitForRequest{Channel: "built"})
+if err := server.WaitFor(ctx, tmux.WaitForRequest{
+    Channel: "built", Mode: tmux.WaitForModeSignal,
+}); err != nil {
+    return err
+}
+if err := server.WaitFor(ctx, tmux.WaitForRequest{Channel: "built"}); err != nil {
+    return err
+}
 ```
 
 ```rust
@@ -190,10 +238,27 @@ channel returns immediately, so completion is not lost when the command finishes
 first.
 
 A raw `wait-for` client can exit zero when the server dies, as well as when the
-channel is signalled. Java's `WakeReason` and Swift's `wait(for:)` distinguish
-server loss from a signal; Swift checks the server PID before and after the
-wait.
-
-Use a channel name specific to the task, or clear an old signal with Java's
-`drain()` when appropriate. A remembered signal can otherwise satisfy an
-unrelated later wait.
+channel is signalled. Verify server liveness when a lost server must be treated
+as a failed task.
+
+<!-- port:java -->
+Check `WakeReason` to distinguish server loss from a signal. `drain()` can
+clear a remembered signal before reusing a channel.
+<!-- /port -->
+<!-- port:swift -->
+`wait(for:)` checks the server PID before and after waiting to distinguish
+server loss from a signal.
+<!-- /port -->
+
+Use a channel name specific to the task. A remembered signal can otherwise
+satisfy an unrelated later wait.
+
+<details>
+<summary>tmux manual and source</summary>
+
+The tmux manual describes [completion channels](https://github.com/tmux/tmux/blob/94796f6b1182507efac8a272fc309a79e22e58a5/tmux.1#L8715).
+The [channel implementation](https://github.com/tmux/tmux/blob/94796f6b1182507efac8a272fc309a79e22e58a5/cmd-wait-for.c#L388)
+retains an early signal until a waiter consumes it. Use a fresh channel name
+for each operation.
+
+</details>
diff --git a/site/src/data/api/go.json b/site/src/data/api/go.json
index cbd4b161..7f959052 100644
--- a/site/src/data/api/go.json
+++ b/site/src/data/api/go.json
@@ -1 +1 @@
-{"port":"go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractor":"@libtmux/api-model@0.0.1","symbols":[{"id":"tmux.ModulePath","name":"ModulePath","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ModulePath is the Go module this package belongs to. It is the module path rather than the package path, because that is what Go build metadata records."},"source":{"file":"tmux/build_info.go","line":7,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ModulePath","product":"core","slug":"tmux-modulepath"},{"id":"tmux.PackageVersion","name":"PackageVersion","kind":"function","modifiers":[],"signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PackageVersion returns the release version recorded in Go build metadata. Development builds and binaries without module metadata return \"\", false."},"source":{"file":"tmux/build_info.go","line":11,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PackageVersion","product":"core","slug":"tmux-packageversion"},{"id":"tmux.ClientAttachment","name":"ClientAttachment","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClientAttachment is one immutable view of a client's live attachment. Session, Window, and Pane return values from the same observational Snapshot."},"source":{"file":"tmux/client_attachment.go","line":10,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientAttachment","product":"core","slug":"tmux-clientattachment"},{"id":"tmux.ClientAttachment.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.ClientAttachment","signatures":[{"params":[],"returns":"(Session, bool)"}],"doc":{"summary":"Session returns the attached session, if it remained live in the snapshot."},"source":{"file":"tmux/client_attachment.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientAttachment.Session","product":"core","slug":"tmux-clientattachment-session"},{"id":"tmux.ClientAttachment.Window","name":"Window","kind":"method","modifiers":[],"parent":"tmux.ClientAttachment","signatures":[{"params":[],"returns":"(Window, bool)"}],"doc":{"summary":"Window returns the attached session's active winlink, if present."},"source":{"file":"tmux/client_attachment.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientAttachment.Window","product":"core","slug":"tmux-clientattachment-window"},{"id":"tmux.ClientAttachment.Pane","name":"Pane","kind":"method","modifiers":[],"parent":"tmux.ClientAttachment","signatures":[{"params":[],"returns":"(Pane, bool)"}],"doc":{"summary":"Pane returns the attached session's active window's active pane, if present."},"source":{"file":"tmux/client_attachment.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientAttachment.Pane","product":"core","slug":"tmux-clientattachment-pane"},{"id":"tmux.Client.ResolveAttachment","name":"ResolveAttachment","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ClientAttachment, error)"}],"doc":{"summary":"ResolveAttachment re-reads the client's live attached hierarchy.","body":"One resolution materializes one strict Snapshot. Snapshot collection is a\nmulti-command observational read, so concurrent tmux changes may produce a\npartial hierarchy. A missing client, detached client, or stale session\nreturns an empty attachment without an error. Other collection, decoding,\nand cardinality errors remain visible."},"source":{"file":"tmux/client_attachment.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.ResolveAttachment","product":"core","slug":"tmux-client-resolveattachment"},{"id":"tmux.ErrUnknownColor","name":"ErrUnknownColor","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrUnknownColor identifies an unsupported tmux color mode. It is matched by errors.Is for [ColorError]."},"source":{"file":"tmux/command.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrUnknownColor","product":"core","slug":"tmux-errunknowncolor"},{"id":"tmux.ErrCommand","name":"ErrCommand","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrCommand identifies a failed high-level tmux command. It is matched by errors.Is for [CommandError]."},"source":{"file":"tmux/command.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrCommand","product":"core","slug":"tmux-errcommand"},{"id":"tmux.ErrNoServer","name":"ErrNoServer","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrNoServer identifies a command that no tmux server answered. A [CommandError] may match both ErrNoServer and [ErrCommand]. tmux cannot reliably distinguish an absent or unreachable server from one that exited during the command."},"source":{"file":"tmux/command.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrNoServer","product":"core","slug":"tmux-errnoserver"},{"id":"tmux.ErrNotFound","name":"ErrNotFound","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrNotFound identifies an operation naming a tmux object that does not exist. A lookup that found nothing matches it, and so does a command tmux refused because the target it named was gone — the same condition reached from either direction. [SnapshotLookupError] and [CommandError] match it through errors.Is.","body":"Only a claim of absence this package has not disproved matches. A lookup\nthat reaches a replaced daemon, or whose diagnostic names an object it did\nnot target, reports what it saw rather than an absence."},"source":{"file":"tmux/command.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrNotFound","product":"core","slug":"tmux-errnotfound"},{"id":"tmux.ColorMode","name":"ColorMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ColorMode selects a tmux color-capability override for [ServerOptions]."},"source":{"file":"tmux/command.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ColorMode","product":"core","slug":"tmux-colormode"},{"id":"tmux.ColorDefault","name":"ColorDefault","kind":"constant","modifiers":[],"signatures":[],"type":"ColorMode","doc":{"summary":"ColorDefault preserves tmux's detected color capability."},"source":{"file":"tmux/command.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ColorDefault","product":"core","slug":"tmux-colordefault"},{"id":"tmux.Color88","name":"Color88","kind":"constant","modifiers":[],"signatures":[],"type":"ColorMode","doc":{"summary":"Color88 requests tmux's 88-color capability mode."},"source":{"file":"tmux/command.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Color88","product":"core","slug":"tmux-color88"},{"id":"tmux.Color256","name":"Color256","kind":"constant","modifiers":[],"signatures":[],"type":"ColorMode","doc":{"summary":"Color256 requests tmux's 256-color capability mode."},"source":{"file":"tmux/command.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Color256","product":"core","slug":"tmux-color256"},{"id":"tmux.ColorError","name":"ColorError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ColorError reports an unsupported color mode. It matches [ErrUnknownColor] through errors.Is; callers can recover Mode with errors.As."},"source":{"file":"tmux/command.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ColorError","product":"core","slug":"tmux-colorerror"},{"id":"tmux.ColorError.Mode","name":"Mode","kind":"attribute","modifiers":[],"parent":"tmux.ColorError","signatures":[],"type":"ColorMode","doc":{"summary":"Mode is the rejected color-capability override."},"source":{"file":"tmux/command.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ColorError.Mode","product":"core","slug":"tmux-colorerror-mode"},{"id":"tmux.ColorError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ColorError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/command.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ColorError.Error","product":"core","slug":"tmux-colorerror-error"},{"id":"tmux.ColorError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ColorError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ColorError compatible with ErrUnknownColor."},"source":{"file":"tmux/command.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ColorError.Unwrap","product":"core","slug":"tmux-colorerror-unwrap"},{"id":"tmux.CommandResult","name":"CommandResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandResult contains one completed tmux invocation. [Server.Cmd] returns it even when tmux exits nonzero. Library operations clone its slices before returning it, so the caller owns Command, Stdout, RawStdout, and Stderr."},"source":{"file":"tmux/command.go","line":72,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandResult","product":"core","slug":"tmux-commandresult"},{"id":"tmux.CommandResult.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"[]string","doc":{"summary":"Command is the executed tmux argument vector."},"source":{"file":"tmux/command.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandResult.Command","product":"core","slug":"tmux-commandresult-command"},{"id":"tmux.CommandResult.Stdout","name":"Stdout","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"[]string","doc":{"summary":"Stdout contains one decoded standard-output line per element."},"source":{"file":"tmux/command.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandResult.Stdout","product":"core","slug":"tmux-commandresult-stdout"},{"id":"tmux.CommandResult.RawStdout","name":"RawStdout","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"[]byte","doc":{"summary":"RawStdout contains exact captured standard-output bytes, including line delimiters and trailing newlines. It is nil when no output was captured."},"source":{"file":"tmux/command.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandResult.RawStdout","product":"core","slug":"tmux-commandresult-rawstdout"},{"id":"tmux.CommandResult.Stderr","name":"Stderr","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"[]string","doc":{"summary":"Stderr contains one decoded standard-error line per element."},"source":{"file":"tmux/command.go","line":81,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandResult.Stderr","product":"core","slug":"tmux-commandresult-stderr"},{"id":"tmux.CommandResult.ExitCode","name":"ExitCode","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"int","doc":{"summary":"ExitCode is tmux's completed process exit code, or -1 when no tmux command ran: this package refused the request, or a transport failed before tmux answered. A negative code is therefore never tmux's opinion of the request, and an error carrying one has a reason of its own."},"source":{"file":"tmux/command.go","line":86,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandResult.ExitCode","product":"core","slug":"tmux-commandresult-exitcode"},{"id":"tmux.CommandError","name":"CommandError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandError reports a completed failed high-level tmux operation. It matches [ErrCommand] through errors.Is; callers can recover its fields with errors.As. Generic library operations retain an owned copy of the completed command and output so tmux diagnostics remain available. Operations whose primary payload may contain secrets return an exit-code-only result instead. Callers must treat retained argv and output as potentially sensitive."},"source":{"file":"tmux/command.go","line":121,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandError","product":"core","slug":"tmux-commanderror"},{"id":"tmux.CommandError.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.CommandError","signatures":[],"type":"string","doc":{"summary":"Subcommand is the failed tmux subcommand."},"source":{"file":"tmux/command.go","line":123,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandError.Subcommand","product":"core","slug":"tmux-commanderror-subcommand"},{"id":"tmux.CommandError.Result","name":"Result","kind":"attribute","modifiers":[],"parent":"tmux.CommandError","signatures":[],"type":"CommandResult","doc":{"summary":"Result is the owned completed result, or an exit-code-only redacted result for a secret-bearing operation."},"source":{"file":"tmux/command.go","line":126,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandError.Result","product":"core","slug":"tmux-commanderror-result"},{"id":"tmux.CommandError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.CommandError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/command.go","line":133,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandError.Error","product":"core","slug":"tmux-commanderror-error"},{"id":"tmux.CommandError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.CommandError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes CommandError compatible with ErrCommand."},"source":{"file":"tmux/command.go","line":142,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandError.Unwrap","product":"core","slug":"tmux-commanderror-unwrap"},{"id":"tmux.CommandError.Is","name":"Is","kind":"method","modifiers":[],"parent":"tmux.CommandError","signatures":[{"params":[{"name":"target","type":"error"}],"returns":"bool"}],"doc":{"summary":"Is reports [ErrNoServer] for a failure that means no tmux server answered — either the command never reached one, or the one it reached is gone — and [ErrNotFound] for one tmux refused because the object it named was absent."},"source":{"file":"tmux/command.go","line":149,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandError.Is","product":"core","slug":"tmux-commanderror-is"},{"id":"tmux.ErrMalformedComplexOption","name":"ErrMalformedComplexOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedComplexOption identifies an invalid entry in a parsed complex option."},"source":{"file":"tmux/complex_options.go","line":11,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrMalformedComplexOption","product":"core","slug":"tmux-errmalformedcomplexoption"},{"id":"tmux.ComplexOptionDecodeError","name":"ComplexOptionDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ComplexOptionDecodeError identifies one malformed sparse-array entry without retaining its raw value."},"source":{"file":"tmux/complex_options.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ComplexOptionDecodeError","product":"core","slug":"tmux-complexoptiondecodeerror"},{"id":"tmux.ComplexOptionDecodeError.Option","name":"Option","kind":"attribute","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[],"type":"string","doc":{"summary":"Option is the option name whose sparse-array entry was malformed."},"source":{"file":"tmux/complex_options.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ComplexOptionDecodeError.Option","product":"core","slug":"tmux-complexoptiondecodeerror-option"},{"id":"tmux.ComplexOptionDecodeError.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[],"type":"int","doc":{"summary":"Index is the zero-based sparse-array entry index."},"source":{"file":"tmux/complex_options.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ComplexOptionDecodeError.Index","product":"core","slug":"tmux-complexoptiondecodeerror-index"},{"id":"tmux.ComplexOptionDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes the syntax failure without retaining raw option contents."},"source":{"file":"tmux/complex_options.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ComplexOptionDecodeError.Reason","product":"core","slug":"tmux-complexoptiondecodeerror-reason"},{"id":"tmux.ComplexOptionDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/complex_options.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ComplexOptionDecodeError.Error","product":"core","slug":"tmux-complexoptiondecodeerror-error"},{"id":"tmux.ComplexOptionDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ComplexOptionDecodeError compatible with ErrMalformedComplexOption."},"source":{"file":"tmux/complex_options.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ComplexOptionDecodeError.Unwrap","product":"core","slug":"tmux-complexoptiondecodeerror-unwrap"},{"id":"tmux.CommandAlias","name":"CommandAlias","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandAlias is one parsed command-alias entry."},"source":{"file":"tmux/complex_options.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandAlias","product":"core","slug":"tmux-commandalias"},{"id":"tmux.CommandAlias.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.CommandAlias","signatures":[],"type":"string","doc":{"summary":"Name is the alias name."},"source":{"file":"tmux/complex_options.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandAlias.Name","product":"core","slug":"tmux-commandalias-name"},{"id":"tmux.CommandAlias.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.CommandAlias","signatures":[],"type":"string","doc":{"summary":"Command is the tmux command text associated with Name."},"source":{"file":"tmux/complex_options.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandAlias.Command","product":"core","slug":"tmux-commandalias-command"},{"id":"tmux.CommandAliases","name":"CommandAliases","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandAliases is an immutable parsed command-alias option. Its zero value is an empty collection: Len is zero, Lookup reports false, and Entries returns a nonnil empty slice."},"source":{"file":"tmux/complex_options.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandAliases","product":"core","slug":"tmux-commandaliases"},{"id":"tmux.CommandAliases.Lookup","name":"Lookup","kind":"method","modifiers":[],"parent":"tmux.CommandAliases","signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(string, bool)"}],"doc":{"summary":"Lookup returns the command registered for name."},"source":{"file":"tmux/complex_options.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandAliases.Lookup","product":"core","slug":"tmux-commandaliases-lookup"},{"id":"tmux.CommandAliases.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.CommandAliases","signatures":[{"params":[],"returns":"[]CommandAlias"}],"doc":{"summary":"Entries returns a fresh slice in first-definition order."},"source":{"file":"tmux/complex_options.go","line":64,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandAliases.Entries","product":"core","slug":"tmux-commandaliases-entries"},{"id":"tmux.CommandAliases.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.CommandAliases","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of distinct aliases."},"source":{"file":"tmux/complex_options.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandAliases.Len","product":"core","slug":"tmux-commandaliases-len"},{"id":"tmux.TerminalFeature","name":"TerminalFeature","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalFeature is one terminal pattern and its enabled features."},"source":{"file":"tmux/complex_options.go","line":72,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalFeature","product":"core","slug":"tmux-terminalfeature"},{"id":"tmux.TerminalFeature.Terminal","name":"Terminal","kind":"attribute","modifiers":[],"parent":"tmux.TerminalFeature","signatures":[],"type":"string","doc":{"summary":"Terminal is the terminal pattern."},"source":{"file":"tmux/complex_options.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalFeature.Terminal","product":"core","slug":"tmux-terminalfeature-terminal"},{"id":"tmux.TerminalFeature.Features","name":"Features","kind":"attribute","modifiers":[],"parent":"tmux.TerminalFeature","signatures":[],"type":"[]string","doc":{"summary":"Features is an owned feature list for Terminal."},"source":{"file":"tmux/complex_options.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalFeature.Features","product":"core","slug":"tmux-terminalfeature-features"},{"id":"tmux.TerminalFeatures","name":"TerminalFeatures","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalFeatures is an immutable parsed terminal-features option. Its zero value is an empty collection: Len is zero, Lookup reports false, and Entries returns a nonnil empty slice."},"source":{"file":"tmux/complex_options.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalFeatures","product":"core","slug":"tmux-terminalfeatures"},{"id":"tmux.TerminalFeatures.Lookup","name":"Lookup","kind":"method","modifiers":[],"parent":"tmux.TerminalFeatures","signatures":[{"params":[{"name":"terminal","type":"string"}],"returns":"([]string, bool)"}],"doc":{"summary":"Lookup returns a fresh feature slice for terminal."},"source":{"file":"tmux/complex_options.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalFeatures.Lookup","product":"core","slug":"tmux-terminalfeatures-lookup"},{"id":"tmux.TerminalFeatures.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.TerminalFeatures","signatures":[{"params":[],"returns":"[]TerminalFeature"}],"doc":{"summary":"Entries returns a deep fresh copy in first-definition order."},"source":{"file":"tmux/complex_options.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalFeatures.Entries","product":"core","slug":"tmux-terminalfeatures-entries"},{"id":"tmux.TerminalFeatures.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.TerminalFeatures","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of distinct terminal patterns."},"source":{"file":"tmux/complex_options.go","line":109,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalFeatures.Len","product":"core","slug":"tmux-terminalfeatures-len"},{"id":"tmux.TerminalOverrideValueKind","name":"TerminalOverrideValueKind","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverrideValueKind identifies one closed terminal capability value form."},"source":{"file":"tmux/complex_options.go","line":112,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValueKind","product":"core","slug":"tmux-terminaloverridevaluekind"},{"id":"tmux.TerminalOverrideValueFlag","name":"TerminalOverrideValueFlag","kind":"constant","modifiers":[],"signatures":[],"type":"TerminalOverrideValueKind","doc":{"summary":"TerminalOverrideValueFlag identifies a capability without an assigned value."},"source":{"file":"tmux/complex_options.go","line":116,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValueFlag","product":"core","slug":"tmux-terminaloverridevalueflag"},{"id":"tmux.TerminalOverrideValueInteger","name":"TerminalOverrideValueInteger","kind":"constant","modifiers":[],"signatures":[],"type":"TerminalOverrideValueKind","doc":{"summary":"TerminalOverrideValueInteger identifies an unsigned decimal integer."},"source":{"file":"tmux/complex_options.go","line":118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValueInteger","product":"core","slug":"tmux-terminaloverridevalueinteger"},{"id":"tmux.TerminalOverrideValueText","name":"TerminalOverrideValueText","kind":"constant","modifiers":[],"signatures":[],"type":"TerminalOverrideValueKind","doc":{"summary":"TerminalOverrideValueText identifies an assigned non-integer string."},"source":{"file":"tmux/complex_options.go","line":120,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValueText","product":"core","slug":"tmux-terminaloverridevaluetext"},{"id":"tmux.TerminalOverrideValue","name":"TerminalOverrideValue","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverrideValue is a flag, arbitrary-precision integer, or string. Its zero value has no recognized kind: IsFlag is false, Integer and Text report false, and it represents no parsed capability assignment."},"source":{"file":"tmux/complex_options.go","line":126,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValue","product":"core","slug":"tmux-terminaloverridevalue"},{"id":"tmux.TerminalOverrideValue.Kind","name":"Kind","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrideValue","signatures":[{"params":[],"returns":"TerminalOverrideValueKind"}],"doc":{"summary":"Kind returns the value's closed form."},"source":{"file":"tmux/complex_options.go","line":132,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValue.Kind","product":"core","slug":"tmux-terminaloverridevalue-kind"},{"id":"tmux.TerminalOverrideValue.IsFlag","name":"IsFlag","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrideValue","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"IsFlag reports whether the capability has no assigned value."},"source":{"file":"tmux/complex_options.go","line":135,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValue.IsFlag","product":"core","slug":"tmux-terminaloverridevalue-isflag"},{"id":"tmux.TerminalOverrideValue.Integer","name":"Integer","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrideValue","signatures":[{"params":[],"returns":"(*big.Int, bool)"}],"doc":{"summary":"Integer returns a fresh arbitrary-precision integer when the value is numeric."},"source":{"file":"tmux/complex_options.go","line":140,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValue.Integer","product":"core","slug":"tmux-terminaloverridevalue-integer"},{"id":"tmux.TerminalOverrideValue.Text","name":"Text","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrideValue","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Text returns the assigned string when the value is textual."},"source":{"file":"tmux/complex_options.go","line":149,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideValue.Text","product":"core","slug":"tmux-terminaloverridevalue-text"},{"id":"tmux.TerminalCapability","name":"TerminalCapability","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalCapability is one parsed terminal override capability."},"source":{"file":"tmux/complex_options.go","line":157,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalCapability","product":"core","slug":"tmux-terminalcapability"},{"id":"tmux.TerminalCapability.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.TerminalCapability","signatures":[],"type":"string","doc":{"summary":"Name is the capability name."},"source":{"file":"tmux/complex_options.go","line":159,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalCapability.Name","product":"core","slug":"tmux-terminalcapability-name"},{"id":"tmux.TerminalCapability.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.TerminalCapability","signatures":[],"type":"TerminalOverrideValue","doc":{"summary":"Value is the parsed capability value."},"source":{"file":"tmux/complex_options.go","line":161,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalCapability.Value","product":"core","slug":"tmux-terminalcapability-value"},{"id":"tmux.TerminalOverride","name":"TerminalOverride","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverride is the immutable capability set for one terminal pattern. Its zero value is an empty immutable collection: Len is zero, Lookup reports false, and Entries returns a nonnil empty slice."},"source":{"file":"tmux/complex_options.go","line":167,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverride","product":"core","slug":"tmux-terminaloverride"},{"id":"tmux.TerminalOverride.Lookup","name":"Lookup","kind":"method","modifiers":[],"parent":"tmux.TerminalOverride","signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(TerminalOverrideValue, bool)"}],"doc":{"summary":"Lookup returns one capability value."},"source":{"file":"tmux/complex_options.go","line":173,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverride.Lookup","product":"core","slug":"tmux-terminaloverride-lookup"},{"id":"tmux.TerminalOverride.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.TerminalOverride","signatures":[{"params":[],"returns":"[]TerminalCapability"}],"doc":{"summary":"Entries returns a fresh slice in first-definition order."},"source":{"file":"tmux/complex_options.go","line":182,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverride.Entries","product":"core","slug":"tmux-terminaloverride-entries"},{"id":"tmux.TerminalOverride.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.TerminalOverride","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of distinct capabilities."},"source":{"file":"tmux/complex_options.go","line":187,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverride.Len","product":"core","slug":"tmux-terminaloverride-len"},{"id":"tmux.TerminalOverrideEntry","name":"TerminalOverrideEntry","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverrideEntry is one terminal pattern and its parsed capabilities."},"source":{"file":"tmux/complex_options.go","line":190,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideEntry","product":"core","slug":"tmux-terminaloverrideentry"},{"id":"tmux.TerminalOverrideEntry.Terminal","name":"Terminal","kind":"attribute","modifiers":[],"parent":"tmux.TerminalOverrideEntry","signatures":[],"type":"string","doc":{"summary":"Terminal is the terminal pattern."},"source":{"file":"tmux/complex_options.go","line":192,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideEntry.Terminal","product":"core","slug":"tmux-terminaloverrideentry-terminal"},{"id":"tmux.TerminalOverrideEntry.Capabilities","name":"Capabilities","kind":"attribute","modifiers":[],"parent":"tmux.TerminalOverrideEntry","signatures":[],"type":"TerminalOverride","doc":{"summary":"Capabilities is the immutable capability set for Terminal."},"source":{"file":"tmux/complex_options.go","line":194,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrideEntry.Capabilities","product":"core","slug":"tmux-terminaloverrideentry-capabilities"},{"id":"tmux.TerminalOverrides","name":"TerminalOverrides","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverrides is an immutable parsed terminal-overrides option. Its zero value is an empty immutable collection: Len is zero, Lookup reports false, and Entries returns a nonnil empty slice."},"source":{"file":"tmux/complex_options.go","line":200,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrides","product":"core","slug":"tmux-terminaloverrides"},{"id":"tmux.TerminalOverrides.Lookup","name":"Lookup","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrides","signatures":[{"params":[{"name":"terminal","type":"string"}],"returns":"(TerminalOverride, bool)"}],"doc":{"summary":"Lookup returns the capabilities for terminal."},"source":{"file":"tmux/complex_options.go","line":206,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrides.Lookup","product":"core","slug":"tmux-terminaloverrides-lookup"},{"id":"tmux.TerminalOverrides.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrides","signatures":[{"params":[],"returns":"[]TerminalOverrideEntry"}],"doc":{"summary":"Entries returns a fresh outer slice in first-definition order. Nested TerminalOverride values remain immutable."},"source":{"file":"tmux/complex_options.go","line":216,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrides.Entries","product":"core","slug":"tmux-terminaloverrides-entries"},{"id":"tmux.TerminalOverrides.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrides","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of distinct terminal patterns."},"source":{"file":"tmux/complex_options.go","line":221,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TerminalOverrides.Len","product":"core","slug":"tmux-terminaloverrides-len"},{"id":"tmux.ServerOptionValues.CommandAliases","name":"CommandAliases","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"(OptionValue[CommandAliases], error)"}],"doc":{"summary":"CommandAliases parses command-alias while preserving option presence and origin. A nonnil joined error contains [ComplexOptionDecodeError] values, each usable with [errors.Is] or [errors.As]; the returned projection still contains every valid entry and is owned by the caller."},"source":{"file":"tmux/complex_options.go","line":227,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.CommandAliases","product":"core","slug":"tmux-serveroptionvalues-commandaliases"},{"id":"tmux.ServerOptionValues.ParsedTerminalFeatures","name":"ParsedTerminalFeatures","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"(OptionValue[TerminalFeatures], error)"}],"doc":{"summary":"ParsedTerminalFeatures parses terminal-features while preserving option presence and origin. A nonnil joined error contains [ComplexOptionDecodeError] values and the returned owned projection contains every valid entry."},"source":{"file":"tmux/complex_options.go","line":253,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.ParsedTerminalFeatures","product":"core","slug":"tmux-serveroptionvalues-parsedterminalfeatures"},{"id":"tmux.ServerOptionValues.ParsedTerminalOverrides","name":"ParsedTerminalOverrides","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"(OptionValue[TerminalOverrides], error)"}],"doc":{"summary":"ParsedTerminalOverrides parses terminal-overrides while preserving option presence and origin. Terminal-overrides syntax is permissive: no malformed entry error is returned, and the result owns its parsed projection."},"source":{"file":"tmux/complex_options.go","line":278,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.ParsedTerminalOverrides","product":"core","slug":"tmux-serveroptionvalues-parsedterminaloverrides"},{"id":"tmux.ErrConnectionRequiresProcess","name":"ErrConnectionRequiresProcess","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrConnectionRequiresProcess identifies an operation refused because a terminal [Connection] cannot start a tmux process outside its owned lanes."},"source":{"file":"tmux/connection.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrConnectionRequiresProcess","product":"core","slug":"tmux-errconnectionrequiresprocess"},{"id":"tmux.ConnectionOptions","name":"ConnectionOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ConnectionOptions configures the control-mode lanes owned by a [Connection]."},"source":{"file":"tmux/connection.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ConnectionOptions","product":"core","slug":"tmux-connectionoptions"},{"id":"tmux.ConnectionOptions.Lanes","name":"Lanes","kind":"attribute","modifiers":[],"parent":"tmux.ConnectionOptions","signatures":[],"type":"int","doc":{"summary":"Lanes is the number of concurrent command lanes. Zero opens one. Each lane is an attached tmux client and carries one command at a time."},"source":{"file":"tmux/connection.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ConnectionOptions.Lanes","product":"core","slug":"tmux-connectionoptions-lanes"},{"id":"tmux.Connection","name":"Connection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Connection owns terminal control-mode transport to the exact daemon that materialized its session. Values obtained from Server or Session retain the connection. Closing is terminal: they neither reconnect nor fall back to a subprocess. Its lanes are attached tmux clients; closing the last client can trigger tmux's destroy-unattached or exit-unattached policy. On tmux 3.6 or later, destroying its initial session moves the clients to another session when one exists; the retained Session value keeps its original identity.","body":"It is what a record runs through. [Server.OpenControl] returns a\n[ControlClient] instead, one client carrying commands and notifications\nwith no record bound to it."},"source":{"file":"tmux/connection.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Connection","product":"core","slug":"tmux-connection"},{"id":"tmux.Server.ConnectionBound","name":"ConnectionBound","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"ConnectionBound reports whether this handle retains terminal transport owned by a [Connection]. A bound handle never reconnects or falls back to a tmux subprocess after that connection closes."},"source":{"file":"tmux/connection.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ConnectionBound","product":"core","slug":"tmux-server-connectionbound"},{"id":"tmux.Session.OpenControl","name":"OpenControl","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"options","type":"ConnectionOptions"}],"returns":"(*Connection, error)"}],"doc":{"summary":"OpenControl opens terminal control-mode transport to the receiver's daemon. The returned connection owns its lanes and must be closed. A receiver already bound to a connection cannot be rebound. Before tmux 3.6, destroying the attached session follows that session's detach-on-destroy policy and may end the connection."},"source":{"file":"tmux/connection.go","line":87,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.OpenControl","product":"core","slug":"tmux-session-opencontrol"},{"id":"tmux.Server.NewSessionConnection","name":"NewSessionConnection","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewSessionRequest"},{"name":"options","type":"ConnectionOptions"}],"returns":"(Session, *Connection, error)"}],"doc":{"summary":"NewSessionConnection creates a session with a control-mode client and keeps that same process as the first terminal command lane. Unlike [Server.NewSession], it creates an attached session. If tmux reports a valid session ID before later setup fails, the returned partial session retains that ID and server. Cleanup closes the attached creator, so tmux policy may make the partial session no longer live. Before tmux 3.6, destroying the created session follows its detach-on-destroy policy and may end the connection. KillExisting is rejected because removing an existing session cannot be rolled back if later connection setup fails."},"source":{"file":"tmux/connection.go","line":124,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.NewSessionConnection","product":"core","slug":"tmux-server-newsessionconnection"},{"id":"tmux.Connection.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the ordinary server value bound to this connection."},"source":{"file":"tmux/connection.go","line":318,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Connection.Server","product":"core","slug":"tmux-connection-server"},{"id":"tmux.Connection.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[],"returns":"Session"}],"doc":{"summary":"Session returns the attached session value bound to this connection."},"source":{"file":"tmux/connection.go","line":321,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Connection.Session","product":"core","slug":"tmux-connection-session"},{"id":"tmux.Connection.Lanes","name":"Lanes","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Lanes reports the number of owned control-mode command lanes."},"source":{"file":"tmux/connection.go","line":324,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Connection.Lanes","product":"core","slug":"tmux-connection-lanes"},{"id":"tmux.Connection.Call","name":"Call","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"([]ControlCommandResult, error)"}],"doc":{"summary":"Call executes one safely encoded tmux command on an owned lane and returns every reply frame in order. An alias may produce zero or multiple frames; a %error frame remains result data through [ControlCommandResult.Failed]. Args always describe one command, so a bare semicolon is quoted as an operand rather than interpreted as a command-list separator."},"source":{"file":"tmux/connection.go","line":336,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Connection.Call","product":"core","slug":"tmux-connection-call"},{"id":"tmux.Connection.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts terminal shutdown and waits within ctx. The context bounds only the wait; a later call may resume waiting for the same shutdown."},"source":{"file":"tmux/connection.go","line":359,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Connection.CloseContext","product":"core","slug":"tmux-connection-closecontext"},{"id":"tmux.Connection.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close terminally closes every lane on bounded internal contexts. It is safe to call concurrently and more than once."},"source":{"file":"tmux/connection.go","line":368,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Connection.Close","product":"core","slug":"tmux-connection-close"},{"id":"tmux.ErrControlClosed","name":"ErrControlClosed","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlClosed identifies an operation attempted after a control client began closing or lost its protocol stream."},"source":{"file":"tmux/control_client.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrControlClosed","product":"core","slug":"tmux-errcontrolclosed"},{"id":"tmux.ErrControlStreamLost","name":"ErrControlStreamLost","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlStreamLost identifies a [ControlClient.NextNotification] stream that ended before the caller asked to close it, distinct from the clean end an explicit Close or CloseContext produces. It is most often the underlying tmux client process exiting because the server it was attached to did."},"source":{"file":"tmux/control_client.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrControlStreamLost","product":"core","slug":"tmux-errcontrolstreamlost"},{"id":"tmux.ErrOutcomeUnknown","name":"ErrOutcomeUnknown","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrOutcomeUnknown identifies a command whose write began but whose reply boundary was not observed. The operation may have changed tmux."},"source":{"file":"tmux/control_client.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrOutcomeUnknown","product":"core","slug":"tmux-erroutcomeunknown"},{"id":"tmux.ErrControlReplyCount","name":"ErrControlReplyCount","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlReplyCount identifies a call to [ControlClient.Cmd] for a command that produced zero or multiple reply frames."},"source":{"file":"tmux/control_client.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrControlReplyCount","product":"core","slug":"tmux-errcontrolreplycount"},{"id":"tmux.ControlClient","name":"ControlClient","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlClient is one attached tmux control-mode process. Create one with [Server.OpenControl]. Concurrent Cmd, Wait, and close calls are supported; exactly one caller may execute NextNotification at a time.","body":"It is the low-level handle: it carries commands and notifications on one\nclient and can [ControlClient.Reconnect], but records do not run through it.\n[Session.OpenControl] returns a [Connection] instead, whose lanes the\nsessions, windows and panes obtained from it use for their own commands."},"source":{"file":"tmux/control_client.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient","product":"core","slug":"tmux-controlclient"},{"id":"tmux.ControlClient.ClientName","name":"ClientName","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[],"returns":"ClientName"}],"doc":{"summary":"ClientName returns the tmux-assigned identity captured during registration."},"source":{"file":"tmux/control_client.go","line":101,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.ClientName","product":"core","slug":"tmux-controlclient-clientname"},{"id":"tmux.ControlClient.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the server handle used to start the control client."},"source":{"file":"tmux/control_client.go","line":104,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.Server","product":"core","slug":"tmux-controlclient-server"},{"id":"tmux.ControlClient.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[],"returns":"Session"}],"doc":{"summary":"Session returns the materialized session selected during startup."},"source":{"file":"tmux/control_client.go","line":107,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.Session","product":"core","slug":"tmux-controlclient-session"},{"id":"tmux.ControlClient.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Wait blocks until the control process exits or ctx ends. It does not close the notification queue; callers may drain final notifications before Close."},"source":{"file":"tmux/control_lifecycle.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.Wait","product":"core","slug":"tmux-controlclient-wait"},{"id":"tmux.ControlClient.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts idempotent control-client shutdown and waits within ctx. The context bounds only the wait: an already-ended context still starts shutdown, and a later call may resume waiting for the same close."},"source":{"file":"tmux/control_lifecycle.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.CloseContext","product":"core","slug":"tmux-controlclient-closecontext"},{"id":"tmux.ControlClient.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the control process and releases its notification queue. It is safe to call concurrently and more than once."},"source":{"file":"tmux/control_lifecycle.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.Close","product":"core","slug":"tmux-controlclient-close"},{"id":"tmux.ControlClient.Reconnect","name":"Reconnect","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(*ControlClient, error)"}],"doc":{"summary":"Reconnect registers a replacement on the last attached session observed at a reply boundary, then closes the receiver. Failed replacement setup does not initiate receiver shutdown. If shutdown fails, Reconnect returns the live replacement with that error; the caller owns every non-nil result. A receiver whose stream ended cleanly can recover from its last observation. Commands are never replayed."},"source":{"file":"tmux/control_lifecycle.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.Reconnect","product":"core","slug":"tmux-controlclient-reconnect"},{"id":"tmux.ErrMalformedControlNotification","name":"ErrMalformedControlNotification","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedControlNotification identifies a structurally invalid control-mode notification."},"source":{"file":"tmux/control_notification.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrMalformedControlNotification","product":"core","slug":"tmux-errmalformedcontrolnotification"},{"id":"tmux.ErrUnknownControlNotification","name":"ErrUnknownControlNotification","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrUnknownControlNotification identifies a well-framed notification kind outside the pinned control-mode vocabulary."},"source":{"file":"tmux/control_notification.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrUnknownControlNotification","product":"core","slug":"tmux-errunknowncontrolnotification"},{"id":"tmux.ControlNotificationError","name":"ControlNotificationError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlNotificationError reports where a control-mode notification failed validation without retaining or disclosing the notification contents. Callers can use [errors.Is] with Category or [errors.As] to inspect its secret-safe location metadata. Category is [ErrMalformedControlNotification] or [ErrUnknownControlNotification]."},"source":{"file":"tmux/control_notification.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationError","product":"core","slug":"tmux-controlnotificationerror"},{"id":"tmux.ControlNotificationError.Offset","name":"Offset","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[],"type":"int","doc":{"summary":"Offset is the byte offset of the malformed protocol element."},"source":{"file":"tmux/control_notification.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationError.Offset","product":"core","slug":"tmux-controlnotificationerror-offset"},{"id":"tmux.ControlNotificationError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[],"type":"string","doc":{"summary":"Reason describes the framing or vocabulary error without retaining input."},"source":{"file":"tmux/control_notification.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationError.Reason","product":"core","slug":"tmux-controlnotificationerror-reason"},{"id":"tmux.ControlNotificationError.Category","name":"Category","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[],"type":"error","doc":{"summary":"Category is ErrMalformedControlNotification or ErrUnknownControlNotification."},"source":{"file":"tmux/control_notification.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationError.Category","product":"core","slug":"tmux-controlnotificationerror-category"},{"id":"tmux.ControlNotificationError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/control_notification.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationError.Error","product":"core","slug":"tmux-controlnotificationerror-error"},{"id":"tmux.ControlNotificationError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ControlNotificationError compatible with its Category."},"source":{"file":"tmux/control_notification.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationError.Unwrap","product":"core","slug":"tmux-controlnotificationerror-unwrap"},{"id":"tmux.ControlNotification","name":"ControlNotification","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlNotification is an immutable parsed tmux control-mode notification. Its zero value has an empty kind and no arguments. Values returned by [ParseControlNotification] own copied arguments and are safe to retain."},"source":{"file":"tmux/control_notification.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotification","product":"core","slug":"tmux-controlnotification"},{"id":"tmux.ControlNotification.Kind","name":"Kind","kind":"method","modifiers":[],"parent":"tmux.ControlNotification","signatures":[{"params":[],"returns":"ControlNotificationKind"}],"doc":{"summary":"Kind returns the notification's protocol kind."},"source":{"file":"tmux/control_notification.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotification.Kind","product":"core","slug":"tmux-controlnotification-kind"},{"id":"tmux.ControlNotification.Arguments","name":"Arguments","kind":"method","modifiers":[],"parent":"tmux.ControlNotification","signatures":[{"params":[],"returns":"[]string"}],"doc":{"summary":"Arguments returns an owned copy of the notification arguments. Arguments before a documented free-form tail are individual values; the tail is the final value and preserves its spacing and tmux escaping."},"source":{"file":"tmux/control_notification.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotification.Arguments","product":"core","slug":"tmux-controlnotification-arguments"},{"id":"tmux.ControlNotification.Output","name":"Output","kind":"method","modifiers":[],"parent":"tmux.ControlNotification","signatures":[{"params":[],"returns":"(PaneID, []byte, bool)"}],"doc":{"summary":"Output returns the pane identity and decoded caller-owned bytes carried by an output or extended-output notification. Other notification kinds return zero values and false."},"source":{"file":"tmux/control_notification.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotification.Output","product":"core","slug":"tmux-controlnotification-output"},{"id":"tmux.SubscriptionChange","name":"SubscriptionChange","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SubscriptionChange is one evaluated format value reported by a subscription armed with [NotificationStream.Subscribe]. The scope fields tmux did not evaluate against are zero: a session-scoped subscription reports no window or pane, and a window-scoped one reports no pane."},"source":{"file":"tmux/control_notification.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionChange","product":"core","slug":"tmux-subscriptionchange"},{"id":"tmux.SubscriptionChange.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"string","doc":{"summary":"Name is the subscription name given when it was armed."},"source":{"file":"tmux/control_notification.go","line":78,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionChange.Name","product":"core","slug":"tmux-subscriptionchange-name"},{"id":"tmux.SubscriptionChange.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"SessionID","doc":{"summary":"Session is the session the value was evaluated for."},"source":{"file":"tmux/control_notification.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionChange.Session","product":"core","slug":"tmux-subscriptionchange-session"},{"id":"tmux.SubscriptionChange.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"WindowID","doc":{"summary":"Window is the window the value was evaluated for, when scoped to one."},"source":{"file":"tmux/control_notification.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionChange.Window","product":"core","slug":"tmux-subscriptionchange-window"},{"id":"tmux.SubscriptionChange.WindowIndex","name":"WindowIndex","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"int","doc":{"summary":"WindowIndex is Window's index in Session. It means nothing when Window is zero."},"source":{"file":"tmux/control_notification.go","line":85,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionChange.WindowIndex","product":"core","slug":"tmux-subscriptionchange-windowindex"},{"id":"tmux.SubscriptionChange.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"PaneID","doc":{"summary":"Pane is the pane the value was evaluated for, when scoped to one."},"source":{"file":"tmux/control_notification.go","line":87,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionChange.Pane","product":"core","slug":"tmux-subscriptionchange-pane"},{"id":"tmux.SubscriptionChange.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"string","doc":{"summary":"Value is the format expanded by tmux."},"source":{"file":"tmux/control_notification.go","line":89,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionChange.Value","product":"core","slug":"tmux-subscriptionchange-value"},{"id":"tmux.ControlNotification.Subscription","name":"Subscription","kind":"method","modifiers":[],"parent":"tmux.ControlNotification","signatures":[{"params":[],"returns":"(SubscriptionChange, bool)"}],"doc":{"summary":"Subscription returns the change carried by a subscription-changed notification. Other notification kinds return a zero value and false."},"source":{"file":"tmux/control_notification.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotification.Subscription","product":"core","slug":"tmux-controlnotification-subscription"},{"id":"tmux.ParseControlNotification","name":"ParseControlNotification","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"line","type":"[]byte"}],"returns":"(ControlNotification, error)"}],"doc":{"summary":"ParseControlNotification parses one newline-free tmux control-mode notification record. It requires exact control framing and a supported kind, returns errors compatible with [ErrMalformedControlNotification] or [ErrUnknownControlNotification], and copies all caller-owned input before returning. It never returns a partial notification."},"source":{"file":"tmux/control_notification.go","line":125,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ParseControlNotification","product":"core","slug":"tmux-parsecontrolnotification"},{"id":"tmux.ErrControlNotificationOverflow","name":"ErrControlNotificationOverflow","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlNotificationOverflow identifies a watcher that did not consume notifications before its bounded backlog filled."},"source":{"file":"tmux/control_notification_queue.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrControlNotificationOverflow","product":"core","slug":"tmux-errcontrolnotificationoverflow"},{"id":"tmux.ControlNotificationOverflowError","name":"ControlNotificationOverflowError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlNotificationOverflowError reports the backlog limit and the record that would have crossed it. The queued prefix remains available first."},"source":{"file":"tmux/control_notification_queue.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationOverflowError","product":"core","slug":"tmux-controlnotificationoverflowerror"},{"id":"tmux.ControlNotificationOverflowError.LimitBytes","name":"LimitBytes","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[],"type":"int","doc":{"summary":"LimitBytes is the maximum retained payload and queue framing."},"source":{"file":"tmux/control_notification_queue.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationOverflowError.LimitBytes","product":"core","slug":"tmux-controlnotificationoverflowerror-limitbytes"},{"id":"tmux.ControlNotificationOverflowError.PendingBytes","name":"PendingBytes","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[],"type":"int","doc":{"summary":"PendingBytes is the unread payload and queue framing retained at overflow."},"source":{"file":"tmux/control_notification_queue.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationOverflowError.PendingBytes","product":"core","slug":"tmux-controlnotificationoverflowerror-pendingbytes"},{"id":"tmux.ControlNotificationOverflowError.NotificationBytes","name":"NotificationBytes","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[],"type":"int","doc":{"summary":"NotificationBytes is the size of the first notification not retained."},"source":{"file":"tmux/control_notification_queue.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationOverflowError.NotificationBytes","product":"core","slug":"tmux-controlnotificationoverflowerror-notificationbytes"},{"id":"tmux.ControlNotificationOverflowError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error describes the bounded backlog without disclosing notification data."},"source":{"file":"tmux/control_notification_queue.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationOverflowError.Error","product":"core","slug":"tmux-controlnotificationoverflowerror-error"},{"id":"tmux.ControlNotificationOverflowError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ControlNotificationOverflowError compatible with ErrControlNotificationOverflow."},"source":{"file":"tmux/control_notification_queue.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationOverflowError.Unwrap","product":"core","slug":"tmux-controlnotificationoverflowerror-unwrap"},{"id":"tmux.ErrPaneObservationLost","name":"ErrPaneObservationLost","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrPaneObservationLost identifies a pane observation whose control client can no longer receive every byte after its baseline. Stream failures that wrap it also preserve their underlying cause."},"source":{"file":"tmux/control_observation.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrPaneObservationLost","product":"core","slug":"tmux-errpaneobservationlost"},{"id":"tmux.PaneObservation","name":"PaneObservation","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneObservation is one visible pane baseline followed by the exact control notification stream after that baseline. That stream is the observation's whole control connection, so a caller wanting only this pane's output selects it by identifier. Create one with [Pane.OpenObservation] and close it when finished. Copies share notification reader ownership, terminal loss, and client lifetime; closing one closes them all."},"source":{"file":"tmux/control_observation.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation","product":"core","slug":"tmux-paneobservation"},{"id":"tmux.PaneObservation.PaneID","name":"PaneID","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"PaneID"}],"doc":{"summary":"PaneID returns the pane selected at the observation boundary."},"source":{"file":"tmux/control_observation.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.PaneID","product":"core","slug":"tmux-paneobservation-paneid"},{"id":"tmux.PaneObservation.SessionID","name":"SessionID","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"SessionID"}],"doc":{"summary":"SessionID returns the session the observation's own control client attached to, resolved live when the observation opened - the session a listing must count this client's attachment against, not merely the pane's session at some other, possibly stale, snapshot."},"source":{"file":"tmux/control_observation.go","line":66,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.SessionID","product":"core","slug":"tmux-paneobservation-sessionid"},{"id":"tmux.PaneObservation.ClientName","name":"ClientName","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"ClientName"}],"doc":{"summary":"ClientName returns the observation's own control client identity - the name a listing of attached clients must exclude, the same way it already excludes a caller's long-lived command connection, so a caller's own stream never reads as another person watching."},"source":{"file":"tmux/control_observation.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.ClientName","product":"core","slug":"tmux-paneobservation-clientname"},{"id":"tmux.PaneObservation.Baseline","name":"Baseline","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"[]string"}],"doc":{"summary":"Baseline returns an owned copy of the pane's visible text at the observation boundary."},"source":{"file":"tmux/control_observation.go","line":86,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.Baseline","product":"core","slug":"tmux-paneobservation-baseline"},{"id":"tmux.PaneObservation.NextNotification","name":"NextNotification","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ControlNotification, error)"}],"doc":{"summary":"NextNotification returns the next notification strictly after the pane baseline, from the whole connection rather than this pane alone. Notifications queued before that boundary are discarded. Concurrent calls are serialized. Caller context errors and [ControlNotificationError] affect only one call. Explicit close returns an error matching [os.ErrClosed].","body":"Topology loss, natural stream EOF, and terminal reader errors return\n[ErrPaneObservationLost]. Stream failures preserve their cause. Later calls\nreturn that loss without consuming more notifications."},"source":{"file":"tmux/control_observation.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.NextNotification","product":"core","slug":"tmux-paneobservation-nextnotification"},{"id":"tmux.PaneObservation.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the dedicated control client. It is safe to call more than once."},"source":{"file":"tmux/control_observation.go","line":271,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.Close","product":"core","slug":"tmux-paneobservation-close"},{"id":"tmux.PaneObservation.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts idempotent observation shutdown and waits within ctx."},"source":{"file":"tmux/control_observation.go","line":279,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.CloseContext","product":"core","slug":"tmux-paneobservation-closecontext"},{"id":"tmux.Pane.OpenObservation","name":"OpenObservation","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(*PaneObservation, error)"}],"doc":{"summary":"OpenObservation captures the pane's visible text and returns an owned observation whose notifications begin at the capture's exact control-wire boundary. It resolves the pane's exact linked session before opening a dedicated control client. The caller must close the result."},"source":{"file":"tmux/control_observation.go","line":290,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.OpenObservation","product":"core","slug":"tmux-pane-openobservation"},{"id":"tmux.PaneObservation.Reader","name":"Reader","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"io.Reader"}],"doc":{"summary":"Reader returns the pane's output after the baseline as a byte stream: what the program in the pane writes to its terminal, in order, and nothing from any other pane on the connection. Reads block until the pane writes, ctx ends, or the observation closes. A lost observation ends the stream with [ErrPaneObservationLost] rather than [io.EOF]. The bytes are the terminal's: escape sequences and carriage returns arrive as written, and the echo of what is typed into the pane arrives before the reply, as it does on screen. Exactly one reader or direct notification read may run at a time.","body":"A malformed notification on the connection is skipped, as\n[PaneObservation.Notifications] skips it; every other error ends the stream."},"source":{"file":"tmux/control_observation.go","line":453,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.Reader","product":"core","slug":"tmux-paneobservation-reader"},{"id":"tmux.PaneObservation.Notifications","name":"Notifications","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"iter.Seq2[ControlNotification, error]"}],"doc":{"summary":"Notifications returns [PaneObservation.NextNotification] as a range loop; exactly one iterator or direct read may run at a time. Malformed notifications yield their error and iteration continues; every other error ends the loop after being yielded."},"source":{"file":"tmux/control_observation.go","line":490,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.Notifications","product":"core","slug":"tmux-paneobservation-notifications"},{"id":"tmux.ErrControlProtocol","name":"ErrControlProtocol","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlProtocol identifies malformed tmux control-mode framing."},"source":{"file":"tmux/control_protocol.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrControlProtocol","product":"core","slug":"tmux-errcontrolprotocol"},{"id":"tmux.ControlProtocolError","name":"ControlProtocolError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlProtocolError reports a control-stream state violation without retaining or disclosing command output or notification contents. It matches [ErrControlProtocol] through errors.Is."},"source":{"file":"tmux/control_protocol.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlProtocolError","product":"core","slug":"tmux-controlprotocolerror"},{"id":"tmux.ControlProtocolError.State","name":"State","kind":"attribute","modifiers":[],"parent":"tmux.ControlProtocolError","signatures":[],"type":"string","doc":{"summary":"State is the parser state in which the violation occurred."},"source":{"file":"tmux/control_protocol.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlProtocolError.State","product":"core","slug":"tmux-controlprotocolerror-state"},{"id":"tmux.ControlProtocolError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.ControlProtocolError","signatures":[],"type":"string","doc":{"summary":"Reason describes the structural violation without quoting input."},"source":{"file":"tmux/control_protocol.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlProtocolError.Reason","product":"core","slug":"tmux-controlprotocolerror-reason"},{"id":"tmux.ControlProtocolError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ControlProtocolError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/control_protocol.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlProtocolError.Error","product":"core","slug":"tmux-controlprotocolerror-error"},{"id":"tmux.ControlProtocolError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ControlProtocolError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ControlProtocolError compatible with ErrControlProtocol."},"source":{"file":"tmux/control_protocol.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlProtocolError.Unwrap","product":"core","slug":"tmux-controlprotocolerror-unwrap"},{"id":"tmux.ControlCommandResult","name":"ControlCommandResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlCommandResult is one completed control-mode command frame. A failed tmux command remains result data through Failed; local, protocol, transport, and context failures are returned separately by [Connection.Call], [ControlClient.Cmd], and [ControlClient.Call]. All slices are owned by the caller."},"source":{"file":"tmux/control_protocol.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlCommandResult","product":"core","slug":"tmux-controlcommandresult"},{"id":"tmux.ControlCommandResult.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"[]string","doc":{"summary":"Command is the safely encoded command's original argument vector."},"source":{"file":"tmux/control_protocol.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlCommandResult.Command","product":"core","slug":"tmux-controlcommandresult-command"},{"id":"tmux.ControlCommandResult.RawStdout","name":"RawStdout","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"[]byte","doc":{"summary":"RawStdout contains exact frame payload bytes, including each line's LF."},"source":{"file":"tmux/control_protocol.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlCommandResult.RawStdout","product":"core","slug":"tmux-controlcommandresult-rawstdout"},{"id":"tmux.ControlCommandResult.Timestamp","name":"Timestamp","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"int64","doc":{"summary":"Timestamp is tmux's frame timestamp in Unix seconds."},"source":{"file":"tmux/control_protocol.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlCommandResult.Timestamp","product":"core","slug":"tmux-controlcommandresult-timestamp"},{"id":"tmux.ControlCommandResult.Number","name":"Number","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"uint64","doc":{"summary":"Number is tmux's command number for the frame. tmux counts commands the server processed rather than commands this client sent, so a command from any other client advances it too and the gap between two frames is not a count of this client's work."},"source":{"file":"tmux/control_protocol.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlCommandResult.Number","product":"core","slug":"tmux-controlcommandresult-number"},{"id":"tmux.ControlCommandResult.Flags","name":"Flags","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"int","doc":{"summary":"Flags contains tmux's frame flags."},"source":{"file":"tmux/control_protocol.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlCommandResult.Flags","product":"core","slug":"tmux-controlcommandresult-flags"},{"id":"tmux.ControlCommandResult.Failed","name":"Failed","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"bool","doc":{"summary":"Failed reports whether tmux closed the frame with %error instead of %end."},"source":{"file":"tmux/control_protocol.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlCommandResult.Failed","product":"core","slug":"tmux-controlcommandresult-failed"},{"id":"tmux.ControlClient.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(ControlCommandResult, error)"}],"doc":{"summary":"Cmd executes one safely encoded tmux command through the control client. It requires exactly one reply frame and returns [ErrControlReplyCount] otherwise. Use [ControlClient.Call] for aliases that may produce zero or multiple frames."},"source":{"file":"tmux/control_request.go","line":95,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.Cmd","product":"core","slug":"tmux-controlclient-cmd"},{"id":"tmux.ControlClient.Call","name":"Call","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"([]ControlCommandResult, error)"}],"doc":{"summary":"Call executes one safely encoded tmux command and returns all its reply frames. Cancellation after writing returns [ErrOutcomeUnknown] with the context error while the client drains through the boundary before reuse. A transport failure returns any frames proven before the failure together with [ErrOutcomeUnknown]."},"source":{"file":"tmux/control_request.go","line":118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.Call","product":"core","slug":"tmux-controlclient-call"},{"id":"tmux.Server.OpenControl","name":"OpenControl","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"session","type":"Session"}],"returns":"(*ControlClient, error)"}],"doc":{"summary":"OpenControl starts a control-mode client attached to session. The startup context bounds process start, attach framing, and client registration but does not own the returned client's lifetime. Session must belong to the same configured server selector."},"source":{"file":"tmux/control_startup.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.OpenControl","product":"core","slug":"tmux-server-opencontrol"},{"id":"tmux.ControlClient.NextNotification","name":"NextNotification","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ControlNotification, error)"}],"doc":{"summary":"NextNotification returns the next ordered control-mode notification. Exactly one caller may execute it at a time. Close releases the queue and makes subsequent reads report os.ErrClosed, drained through queued notifications first. Natural process exit before a caller asked to close instead reports [ErrControlStreamLost] - most often because the server the underlying tmux client was attached to exited - naming the tmux exit reason when one was sent. A terminal reader error follows notifications queued before that failure. A full bounded queue likewise drains before reporting [ControlNotificationOverflowError]."},"source":{"file":"tmux/control_stream.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.NextNotification","product":"core","slug":"tmux-controlclient-nextnotification"},{"id":"tmux.ControlClient.Notifications","name":"Notifications","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"iter.Seq2[ControlNotification, error]"}],"doc":{"summary":"Notifications returns an iterator over what tmux says without being asked: pane output, and the events behind [ControlNotification].","body":"It is [ControlClient.NextNotification] as a range loop; exactly one iterator\nor direct notification read may run at a time.\n\nfor notification, err := range client.Notifications(ctx) {\n\tif err != nil {\n\t\treturn err\n\t}\n\tif pane, output, ok := notification.Output(); ok {\n\t\thandle(pane, output)\n\t}\n}\n\nMalformed or unknown notifications yield their error and iteration continues.\nEvery other error ends the stream after being yielded, including the\n[ErrControlStreamLost] or os.ErrClosed [ControlClient.NextNotification]\nreports at a natural end.\n\nLeaving early preserves queued notifications for the next read."},"source":{"file":"tmux/control_stream.go","line":89,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlClient.Notifications","product":"core","slug":"tmux-controlclient-notifications"},{"id":"tmux.DisplayMessageRequest","name":"DisplayMessageRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DisplayMessageRequest configures display-message options shared by server, window, and pane scope. A zero request displays tmux's default message and returns nil. Print returns an owned stdout slice instead of displaying only to a client status line. Nil pointer fields omit their flags while pointers to empty values are explicit; a zero TargetClient omits its flag."},"source":{"file":"tmux/display_message.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest","product":"core","slug":"tmux-displaymessagerequest"},{"id":"tmux.DisplayMessageRequest.Message","name":"Message","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"string","doc":{"summary":"Message is the optional status message; an empty message leaves tmux's default behavior."},"source":{"file":"tmux/display_message.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.Message","product":"core","slug":"tmux-displaymessagerequest-message"},{"id":"tmux.DisplayMessageRequest.Print","name":"Print","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"Print returns message output instead of only displaying it."},"source":{"file":"tmux/display_message.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.Print","product":"core","slug":"tmux-displaymessagerequest-print"},{"id":"tmux.DisplayMessageRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"*string","doc":{"summary":"Format selects tmux output formatting."},"source":{"file":"tmux/display_message.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.Format","product":"core","slug":"tmux-displaymessagerequest-format"},{"id":"tmux.DisplayMessageRequest.AllFormats","name":"AllFormats","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"AllFormats includes every available format value."},"source":{"file":"tmux/display_message.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.AllFormats","product":"core","slug":"tmux-displaymessagerequest-allformats"},{"id":"tmux.DisplayMessageRequest.Verbose","name":"Verbose","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"Verbose requests verbose tmux output."},"source":{"file":"tmux/display_message.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.Verbose","product":"core","slug":"tmux-displaymessagerequest-verbose"},{"id":"tmux.DisplayMessageRequest.NoExpand","name":"NoExpand","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"NoExpand disables format expansion and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/display_message.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.NoExpand","product":"core","slug":"tmux-displaymessagerequest-noexpand"},{"id":"tmux.DisplayMessageRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the stable client receiving the display; zero omits -c."},"source":{"file":"tmux/display_message.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.TargetClient","product":"core","slug":"tmux-displaymessagerequest-targetclient"},{"id":"tmux.DisplayMessageRequest.Delay","name":"Delay","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"*time.Duration","doc":{"summary":"Delay sets the display duration. Nil uses tmux's display-time option; an explicit zero waits for a key press unless Notify is set. Values must be whole milliseconds from zero through 4294967295 milliseconds. Invalid values return ErrInvalidServerCommandRequest before tmux I/O."},"source":{"file":"tmux/display_message.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.Delay","product":"core","slug":"tmux-displaymessagerequest-delay"},{"id":"tmux.DisplayMessageRequest.Notify","name":"Notify","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"Notify makes the status message ignore key presses, closing only once Delay elapses."},"source":{"file":"tmux/display_message.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMessageRequest.Notify","product":"core","slug":"tmux-displaymessagerequest-notify"},{"id":"tmux.PaneDisplayMessageRequest","name":"PaneDisplayMessageRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneDisplayMessageRequest adds the pane-only update behavior to the common display-message options."},"source":{"file":"tmux/display_message.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneDisplayMessageRequest","product":"core","slug":"tmux-panedisplaymessagerequest"},{"id":"tmux.PaneDisplayMessageRequest.UpdatePane","name":"UpdatePane","kind":"attribute","modifiers":[],"parent":"tmux.PaneDisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"UpdatePane updates pane state and requires tmux 3.6; see UnsupportedPolicy."},"source":{"file":"tmux/display_message.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneDisplayMessageRequest.UpdatePane","product":"core","slug":"tmux-panedisplaymessagerequest-updatepane"},{"id":"tmux.Server.DisplayMessage","name":"DisplayMessage","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayMessageRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"DisplayMessage displays or prints a server-scoped tmux message. Print returns an owned stdout slice even when tmux exits nonzero; completed stderr is delivered synchronously through [WarningCommandStderr], not returned as a completed-error classification. Unsupported flags follow [UnsupportedPolicy]. Any warnings run on the caller goroutine before return. Cancellation does not prove display did not occur."},"source":{"file":"tmux/display_message.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.DisplayMessage","product":"core","slug":"tmux-server-displaymessage"},{"id":"tmux.Window.DisplayMessage","name":"DisplayMessage","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayMessageRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"DisplayMessage displays or prints a message at this window's exact target. Print returns an owned stdout slice even on a completed nonzero exit; completed stderr reaches [WarningHandler] as [WarningCommandStderr]. NoExpand follows [UnsupportedPolicy]. Warnings run synchronously before return; context cancellation does not prove display did not occur."},"source":{"file":"tmux/display_message.go","line":93,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.DisplayMessage","product":"core","slug":"tmux-window-displaymessage"},{"id":"tmux.Pane.DisplayMessage","name":"DisplayMessage","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PaneDisplayMessageRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"DisplayMessage displays or prints a message at this pane's exact target. Embedded NoExpand requires tmux 3.4 and UpdatePane requires tmux 3.6; each follows [UnsupportedPolicy]. Print returns an owned stdout slice even on a completed nonzero exit. Completed stderr synchronously reaches [WarningHandler] as [WarningCommandStderr], not an error; cancellation does not prove display or pane update did not occur."},"source":{"file":"tmux/display_message.go","line":114,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.DisplayMessage","product":"core","slug":"tmux-pane-displaymessage"},{"id":"tmux.ErrInvalidEnvironmentName","name":"ErrInvalidEnvironmentName","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidEnvironmentName identifies a name tmux cannot store."},"source":{"file":"tmux/environment.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidEnvironmentName","product":"core","slug":"tmux-errinvalidenvironmentname"},{"id":"tmux.ErrInvalidEnvironmentValue","name":"ErrInvalidEnvironmentValue","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidEnvironmentValue identifies a value the line-oriented read API cannot round-trip."},"source":{"file":"tmux/environment.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidEnvironmentValue","product":"core","slug":"tmux-errinvalidenvironmentvalue"},{"id":"tmux.ErrMalformedEnvironment","name":"ErrMalformedEnvironment","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedEnvironment identifies output that is not a tmux environment entry."},"source":{"file":"tmux/environment.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrMalformedEnvironment","product":"core","slug":"tmux-errmalformedenvironment"},{"id":"tmux.SetEnvironmentOptions","name":"SetEnvironmentOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetEnvironmentOptions controls tmux's value expansion and visibility flags. Its zero value stores Value literally and exposes it to child processes."},"source":{"file":"tmux/environment.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetEnvironmentOptions","product":"core","slug":"tmux-setenvironmentoptions"},{"id":"tmux.SetEnvironmentOptions.ExpandFormat","name":"ExpandFormat","kind":"attribute","modifiers":[],"parent":"tmux.SetEnvironmentOptions","signatures":[],"type":"bool","doc":{"summary":"ExpandFormat expands tmux format expressions in Value before storing it."},"source":{"file":"tmux/environment.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetEnvironmentOptions.ExpandFormat","product":"core","slug":"tmux-setenvironmentoptions-expandformat"},{"id":"tmux.SetEnvironmentOptions.Hidden","name":"Hidden","kind":"attribute","modifiers":[],"parent":"tmux.SetEnvironmentOptions","signatures":[],"type":"bool","doc":{"summary":"Hidden keeps the value available to tmux but out of child environments."},"source":{"file":"tmux/environment.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetEnvironmentOptions.Hidden","product":"core","slug":"tmux-setenvironmentoptions-hidden"},{"id":"tmux.EnvironmentValue","name":"EnvironmentValue","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"EnvironmentValue is one tmux environment value or removal marker. Its zero value is an ordinary empty value, not a removal marker."},"source":{"file":"tmux/environment.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentValue","product":"core","slug":"tmux-environmentvalue"},{"id":"tmux.EnvironmentValue.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentValue","signatures":[],"type":"string","doc":{"summary":"Value is the exact value after tmux format expansion, if any."},"source":{"file":"tmux/environment.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentValue.Value","product":"core","slug":"tmux-environmentvalue-value"},{"id":"tmux.EnvironmentValue.Removed","name":"Removed","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentValue","signatures":[],"type":"bool","doc":{"summary":"Removed reports that tmux will remove the variable from new processes."},"source":{"file":"tmux/environment.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentValue.Removed","product":"core","slug":"tmux-environmentvalue-removed"},{"id":"tmux.EnvironmentNameError","name":"EnvironmentNameError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"EnvironmentNameError reports a name that tmux cannot store."},"source":{"file":"tmux/environment.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentNameError","product":"core","slug":"tmux-environmentnameerror"},{"id":"tmux.EnvironmentNameError.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentNameError","signatures":[],"type":"string","doc":{"summary":"Name is the invalid environment variable name."},"source":{"file":"tmux/environment.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentNameError.Name","product":"core","slug":"tmux-environmentnameerror-name"},{"id":"tmux.EnvironmentNameError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.EnvironmentNameError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/environment.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentNameError.Error","product":"core","slug":"tmux-environmentnameerror-error"},{"id":"tmux.EnvironmentNameError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.EnvironmentNameError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes EnvironmentNameError compatible with ErrInvalidEnvironmentName."},"source":{"file":"tmux/environment.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentNameError.Unwrap","product":"core","slug":"tmux-environmentnameerror-unwrap"},{"id":"tmux.EnvironmentValueError","name":"EnvironmentValueError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"EnvironmentValueError reports a value that cannot round-trip through show-environment. It intentionally does not retain or print the environment value."},"source":{"file":"tmux/environment.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentValueError","product":"core","slug":"tmux-environmentvalueerror"},{"id":"tmux.EnvironmentValueError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.EnvironmentValueError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error without disclosing the environment value."},"source":{"file":"tmux/environment.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentValueError.Error","product":"core","slug":"tmux-environmentvalueerror-error"},{"id":"tmux.EnvironmentValueError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.EnvironmentValueError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes EnvironmentValueError compatible with ErrInvalidEnvironmentValue."},"source":{"file":"tmux/environment.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentValueError.Unwrap","product":"core","slug":"tmux-environmentvalueerror-unwrap"},{"id":"tmux.EnvironmentDecodeError","name":"EnvironmentDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"EnvironmentDecodeError reports one malformed show-environment record. It never retains the record because environment output may contain secrets."},"source":{"file":"tmux/environment.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentDecodeError","product":"core","slug":"tmux-environmentdecodeerror"},{"id":"tmux.EnvironmentDecodeError.Record","name":"Record","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentDecodeError","signatures":[],"type":"int","doc":{"summary":"Record is the zero-based malformed output record number."},"source":{"file":"tmux/environment.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentDecodeError.Record","product":"core","slug":"tmux-environmentdecodeerror-record"},{"id":"tmux.EnvironmentDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes malformed framing without retaining the record value."},"source":{"file":"tmux/environment.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentDecodeError.Reason","product":"core","slug":"tmux-environmentdecodeerror-reason"},{"id":"tmux.EnvironmentDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.EnvironmentDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/environment.go","line":73,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentDecodeError.Error","product":"core","slug":"tmux-environmentdecodeerror-error"},{"id":"tmux.EnvironmentDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.EnvironmentDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes EnvironmentDecodeError compatible with ErrMalformedEnvironment."},"source":{"file":"tmux/environment.go","line":78,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.EnvironmentDecodeError.Unwrap","product":"core","slug":"tmux-environmentdecodeerror-unwrap"},{"id":"tmux.Server.SetEnvironment","name":"SetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetEnvironmentOptions"}],"returns":"error"}],"doc":{"summary":"SetEnvironment stores a value in the server's global tmux environment. ExpandFormat and Hidden select tmux flags; cancellation does not prove the value was not stored."},"source":{"file":"tmux/environment.go","line":83,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetEnvironment","product":"core","slug":"tmux-server-setenvironment"},{"id":"tmux.Server.UnsetEnvironment","name":"UnsetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetEnvironment deletes a value from the server's global tmux environment. Cancellation does not prove deletion did not occur."},"source":{"file":"tmux/environment.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.UnsetEnvironment","product":"core","slug":"tmux-server-unsetenvironment"},{"id":"tmux.Server.RemoveEnvironment","name":"RemoveEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RemoveEnvironment marks a variable for removal from new process environments."},"source":{"file":"tmux/environment.go","line":99,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.RemoveEnvironment","product":"core","slug":"tmux-server-removeenvironment"},{"id":"tmux.Server.ShowEnvironment","name":"ShowEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(map[string]EnvironmentValue, error)"}],"doc":{"summary":"ShowEnvironment returns an owned server-global non-hidden tmux environment. Completed command failures return an empty map unless strict errors are enabled. Externally injected multiline entries return ErrMalformedEnvironment because tmux's multi-entry output does not frame continuation lines. Decode errors are compatible with [ErrMalformedEnvironment] and return no partial map."},"source":{"file":"tmux/environment.go","line":108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ShowEnvironment","product":"core","slug":"tmux-server-showenvironment"},{"id":"tmux.Server.GetEnvironment","name":"GetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(EnvironmentValue, bool, error)"}],"doc":{"summary":"GetEnvironment returns one non-hidden global environment entry. A missing or hidden variable reports ok false."},"source":{"file":"tmux/environment.go","line":114,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.GetEnvironment","product":"core","slug":"tmux-server-getenvironment"},{"id":"tmux.Session.SetEnvironment","name":"SetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetEnvironmentOptions"}],"returns":"error"}],"doc":{"summary":"SetEnvironment stores a value in this session's tmux environment, targeted by its stable SessionID."},"source":{"file":"tmux/environment.go","line":123,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetEnvironment","product":"core","slug":"tmux-session-setenvironment"},{"id":"tmux.Session.UnsetEnvironment","name":"UnsetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetEnvironment deletes a value from this session's tmux environment, targeted by its stable SessionID."},"source":{"file":"tmux/environment.go","line":138,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.UnsetEnvironment","product":"core","slug":"tmux-session-unsetenvironment"},{"id":"tmux.Session.RemoveEnvironment","name":"RemoveEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RemoveEnvironment marks a variable for removal from new process environments for this stable session target."},"source":{"file":"tmux/environment.go","line":148,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.RemoveEnvironment","product":"core","slug":"tmux-session-removeenvironment"},{"id":"tmux.Session.ShowEnvironment","name":"ShowEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(map[string]EnvironmentValue, error)"}],"doc":{"summary":"ShowEnvironment returns an owned session-scoped non-hidden tmux environment. Completed command failures return an empty map unless strict errors are enabled. Externally injected multiline entries return ErrMalformedEnvironment because tmux's multi-entry output does not frame continuation lines. Decode errors are compatible with [ErrMalformedEnvironment] and return no partial map."},"source":{"file":"tmux/environment.go","line":161,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ShowEnvironment","product":"core","slug":"tmux-session-showenvironment"},{"id":"tmux.Session.GetEnvironment","name":"GetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(EnvironmentValue, bool, error)"}],"doc":{"summary":"GetEnvironment returns one non-hidden session environment entry for this stable session target. A missing or hidden variable reports ok false."},"source":{"file":"tmux/environment.go","line":172,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.GetEnvironment","product":"core","slug":"tmux-session-getenvironment"},{"id":"tmux.ErrInvalidFilter","name":"ErrInvalidFilter","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidFilter reports a malformed or impossible generated filter. Filter validation, lookup parsing, predicates, and JSON methods wrap this error."},"source":{"file":"tmux/filter.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidFilter","product":"core","slug":"tmux-errinvalidfilter"},{"id":"tmux.Ptr","name":"Ptr","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"T"}],"returns":"*T","typeParams":["T any"]}],"doc":{"summary":"Ptr returns a distinct pointer to a shallow copy of value, including when T has zero size. Its nonzero holder prevents Go from coalescing zero-size addresses. Slices, maps, pointers, and other reference-bearing values still alias their referenced data. Ptr performs no validation or ownership transfer."},"source":{"file":"tmux/filter.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Ptr","product":"core","slug":"tmux-ptr"},{"id":"tmux.FilterSchemaVersion","name":"FilterSchemaVersion","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"FilterSchemaVersion identifies external metadata for the generated filter JSON wire schema. It is not embedded in JSON and is independent of the tmux [Version]."},"source":{"file":"tmux/filter_generated.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FilterSchemaVersion","product":"core","slug":"tmux-filterschemaversion"},{"id":"tmux.SessionFilter","name":"SessionFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionFilter matches materialized [Session] values without tmux I/O. Its zero value matches every non-nil candidate. Criteria are ANDed; AnyOf adds an OR requirement and Not excludes. Field and relation criteria correspond to [Session.ID], [Session.Name], [Session.Attached], [Session.Windows], and [Session.Panes]. [SessionFilter.Validate] and methods that consume the filter reject invalid criteria with [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter","product":"core","slug":"tmux-sessionfilter"},{"id":"tmux.SessionFilter.ID","name":"ID","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*SessionID","doc":{"summary":"ID exactly matches the stable tmux session identifier from Session.ID, including its $ sigil. A nil pointer leaves ID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.ID","product":"core","slug":"tmux-sessionfilter-id"},{"id":"tmux.SessionFilter.IDIn","name":"IDIn","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"[]SessionID","doc":{"summary":"IDIn lists accepted values for the stable tmux session identifier from Session.ID, including its $ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves IDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.IDIn","product":"core","slug":"tmux-sessionfilter-idin"},{"id":"tmux.SessionFilter.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*string","doc":{"summary":"Name exactly matches the materialized session name from Session.Name. A nil pointer leaves Name unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.Name","product":"core","slug":"tmux-sessionfilter-name"},{"id":"tmux.SessionFilter.NameIn","name":"NameIn","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"[]string","doc":{"summary":"NameIn lists accepted values for the materialized session name from Session.Name. A candidate matches when its materialized value equals one listed value. A nil slice leaves NameIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.NameIn","product":"core","slug":"tmux-sessionfilter-namein"},{"id":"tmux.SessionFilter.NameContains","name":"NameContains","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*string","doc":{"summary":"NameContains requires the materialized session name from Session.Name to contain the pointed-to substring. A nil pointer leaves NameContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.NameContains","product":"core","slug":"tmux-sessionfilter-namecontains"},{"id":"tmux.SessionFilter.NameRegex","name":"NameRegex","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"string","doc":{"summary":"NameRegex requires the materialized session name from Session.Name to match Go regular expression syntax. An empty string leaves NameRegex unset."},"source":{"file":"tmux/filter_generated.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.NameRegex","product":"core","slug":"tmux-sessionfilter-nameregex"},{"id":"tmux.SessionFilter.Attached","name":"Attached","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*bool","doc":{"summary":"Attached exactly matches the materialized attachment state from Session.Attached. A nil pointer leaves Attached unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.Attached","product":"core","slug":"tmux-sessionfilter-attached"},{"id":"tmux.SessionFilter.AnyOf","name":"AnyOf","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"[]SessionFilter","doc":{"summary":"AnyOf additionally requires at least one branch to match after ordinary criteria match. A nil slice leaves AnyOf unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.AnyOf","product":"core","slug":"tmux-sessionfilter-anyof"},{"id":"tmux.SessionFilter.Not","name":"Not","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*SessionFilter","doc":{"summary":"Not excludes a candidate when its nested filter matches. A nil pointer leaves Not unset."},"source":{"file":"tmux/filter_generated.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.Not","product":"core","slug":"tmux-sessionfilter-not"},{"id":"tmux.SessionFilter.Windows","name":"Windows","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*WindowRel","doc":{"summary":"Windows traverses the materialized window views returned by Session.Windows. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.Windows","product":"core","slug":"tmux-sessionfilter-windows"},{"id":"tmux.SessionFilter.Panes","name":"Panes","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*PaneRel","doc":{"summary":"Panes traverses the materialized pane views returned by Session.Panes. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.Panes","product":"core","slug":"tmux-sessionfilter-panes"},{"id":"tmux.WindowFilter","name":"WindowFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowFilter matches materialized [Window] values without tmux I/O. Its zero value matches every non-nil candidate. Criteria are ANDed; AnyOf adds an OR requirement and Not excludes. Field and relation criteria correspond to [Window.SessionID], [Window.ID], [Window.Index], [Window.Name], [Window.Active], [Window.Session], and [Window.Panes]. [WindowFilter.Validate] and methods that consume the filter reject invalid criteria with [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter","product":"core","slug":"tmux-windowfilter"},{"id":"tmux.WindowFilter.SessionID","name":"SessionID","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*SessionID","doc":{"summary":"SessionID exactly matches the stable tmux session identifier from Window.SessionID, including its $ sigil. A nil pointer leaves SessionID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.SessionID","product":"core","slug":"tmux-windowfilter-sessionid"},{"id":"tmux.WindowFilter.SessionIDIn","name":"SessionIDIn","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]SessionID","doc":{"summary":"SessionIDIn lists accepted values for the stable tmux session identifier from Window.SessionID, including its $ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves SessionIDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.SessionIDIn","product":"core","slug":"tmux-windowfilter-sessionidin"},{"id":"tmux.WindowFilter.ID","name":"ID","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*WindowID","doc":{"summary":"ID exactly matches the stable tmux window identifier from Window.ID, including its @ sigil. A nil pointer leaves ID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.ID","product":"core","slug":"tmux-windowfilter-id"},{"id":"tmux.WindowFilter.IDIn","name":"IDIn","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]WindowID","doc":{"summary":"IDIn lists accepted values for the stable tmux window identifier from Window.ID, including its @ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves IDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.IDIn","product":"core","slug":"tmux-windowfilter-idin"},{"id":"tmux.WindowFilter.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"Index exactly matches the nonnegative winlink index from Window.Index. A nil pointer leaves Index unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.Index","product":"core","slug":"tmux-windowfilter-index"},{"id":"tmux.WindowFilter.IndexIn","name":"IndexIn","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]int","doc":{"summary":"IndexIn lists accepted values for the nonnegative winlink index from Window.Index. A candidate matches when its materialized value equals one listed value. A nil slice leaves IndexIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":62,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.IndexIn","product":"core","slug":"tmux-windowfilter-indexin"},{"id":"tmux.WindowFilter.IndexGT","name":"IndexGT","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"IndexGT requires the nonnegative winlink index from Window.Index to be strictly greater than the pointed-to value. A nil pointer leaves IndexGT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":64,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.IndexGT","product":"core","slug":"tmux-windowfilter-indexgt"},{"id":"tmux.WindowFilter.IndexGTE","name":"IndexGTE","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"IndexGTE requires the nonnegative winlink index from Window.Index to be greater than or equal to the pointed-to value. A nil pointer leaves IndexGTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":66,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.IndexGTE","product":"core","slug":"tmux-windowfilter-indexgte"},{"id":"tmux.WindowFilter.IndexLT","name":"IndexLT","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"IndexLT requires the nonnegative winlink index from Window.Index to be strictly less than the pointed-to value. A nil pointer leaves IndexLT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":68,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.IndexLT","product":"core","slug":"tmux-windowfilter-indexlt"},{"id":"tmux.WindowFilter.IndexLTE","name":"IndexLTE","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"IndexLTE requires the nonnegative winlink index from Window.Index to be less than or equal to the pointed-to value. A nil pointer leaves IndexLTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":70,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.IndexLTE","product":"core","slug":"tmux-windowfilter-indexlte"},{"id":"tmux.WindowFilter.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*string","doc":{"summary":"Name exactly matches the materialized window name from Window.Name. A nil pointer leaves Name unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":72,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.Name","product":"core","slug":"tmux-windowfilter-name"},{"id":"tmux.WindowFilter.NameIn","name":"NameIn","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]string","doc":{"summary":"NameIn lists accepted values for the materialized window name from Window.Name. A candidate matches when its materialized value equals one listed value. A nil slice leaves NameIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.NameIn","product":"core","slug":"tmux-windowfilter-namein"},{"id":"tmux.WindowFilter.NameContains","name":"NameContains","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*string","doc":{"summary":"NameContains requires the materialized window name from Window.Name to contain the pointed-to substring. A nil pointer leaves NameContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.NameContains","product":"core","slug":"tmux-windowfilter-namecontains"},{"id":"tmux.WindowFilter.NameRegex","name":"NameRegex","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"string","doc":{"summary":"NameRegex requires the materialized window name from Window.Name to match Go regular expression syntax. An empty string leaves NameRegex unset."},"source":{"file":"tmux/filter_generated.go","line":78,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.NameRegex","product":"core","slug":"tmux-windowfilter-nameregex"},{"id":"tmux.WindowFilter.Active","name":"Active","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*bool","doc":{"summary":"Active exactly matches the materialized active state from Window.Active. A nil pointer leaves Active unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.Active","product":"core","slug":"tmux-windowfilter-active"},{"id":"tmux.WindowFilter.AnyOf","name":"AnyOf","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]WindowFilter","doc":{"summary":"AnyOf additionally requires at least one branch to match after ordinary criteria match. A nil slice leaves AnyOf unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.AnyOf","product":"core","slug":"tmux-windowfilter-anyof"},{"id":"tmux.WindowFilter.Not","name":"Not","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*WindowFilter","doc":{"summary":"Not excludes a candidate when its nested filter matches. A nil pointer leaves Not unset."},"source":{"file":"tmux/filter_generated.go","line":84,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.Not","product":"core","slug":"tmux-windowfilter-not"},{"id":"tmux.WindowFilter.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*SessionFilter","doc":{"summary":"Session traverses the materialized parent returned by Window.Session. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":86,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.Session","product":"core","slug":"tmux-windowfilter-session"},{"id":"tmux.WindowFilter.Panes","name":"Panes","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*PaneRel","doc":{"summary":"Panes traverses the materialized pane views returned by Window.Panes. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.Panes","product":"core","slug":"tmux-windowfilter-panes"},{"id":"tmux.PaneFilter","name":"PaneFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneFilter matches materialized [Pane] values without tmux I/O. Its zero value matches every non-nil candidate. Criteria are ANDed; AnyOf adds an OR requirement and Not excludes. Field and relation criteria correspond to [Pane.SessionID], [Pane.WindowID], [Pane.ID], [Pane.WindowIndex], [Pane.Index], [Pane.CurrentCommand], [Pane.Active], [Pane.Title], [Pane.Session], and [Pane.Window]. [PaneFilter.Validate] and methods that consume the filter reject invalid criteria with [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":95,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter","product":"core","slug":"tmux-panefilter"},{"id":"tmux.PaneFilter.SessionID","name":"SessionID","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*SessionID","doc":{"summary":"SessionID exactly matches the stable tmux session identifier from Pane.SessionID, including its $ sigil. A nil pointer leaves SessionID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.SessionID","product":"core","slug":"tmux-panefilter-sessionid"},{"id":"tmux.PaneFilter.SessionIDIn","name":"SessionIDIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]SessionID","doc":{"summary":"SessionIDIn lists accepted values for the stable tmux session identifier from Pane.SessionID, including its $ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves SessionIDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":99,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.SessionIDIn","product":"core","slug":"tmux-panefilter-sessionidin"},{"id":"tmux.PaneFilter.WindowID","name":"WindowID","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*WindowID","doc":{"summary":"WindowID exactly matches the stable tmux window identifier from Pane.WindowID, including its @ sigil. A nil pointer leaves WindowID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":101,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.WindowID","product":"core","slug":"tmux-panefilter-windowid"},{"id":"tmux.PaneFilter.WindowIDIn","name":"WindowIDIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]WindowID","doc":{"summary":"WindowIDIn lists accepted values for the stable tmux window identifier from Pane.WindowID, including its @ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves WindowIDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.WindowIDIn","product":"core","slug":"tmux-panefilter-windowidin"},{"id":"tmux.PaneFilter.ID","name":"ID","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*PaneID","doc":{"summary":"ID exactly matches the stable tmux pane identifier from Pane.ID, including its % sigil. A nil pointer leaves ID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":105,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.ID","product":"core","slug":"tmux-panefilter-id"},{"id":"tmux.PaneFilter.IDIn","name":"IDIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]PaneID","doc":{"summary":"IDIn lists accepted values for the stable tmux pane identifier from Pane.ID, including its % sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves IDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":107,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.IDIn","product":"core","slug":"tmux-panefilter-idin"},{"id":"tmux.PaneFilter.WindowIndex","name":"WindowIndex","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndex exactly matches the nonnegative winlink index from Pane.WindowIndex. A nil pointer leaves WindowIndex unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":109,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.WindowIndex","product":"core","slug":"tmux-panefilter-windowindex"},{"id":"tmux.PaneFilter.WindowIndexIn","name":"WindowIndexIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]int","doc":{"summary":"WindowIndexIn lists accepted values for the nonnegative winlink index from Pane.WindowIndex. A candidate matches when its materialized value equals one listed value. A nil slice leaves WindowIndexIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.WindowIndexIn","product":"core","slug":"tmux-panefilter-windowindexin"},{"id":"tmux.PaneFilter.WindowIndexGT","name":"WindowIndexGT","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndexGT requires the nonnegative winlink index from Pane.WindowIndex to be strictly greater than the pointed-to value. A nil pointer leaves WindowIndexGT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":113,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.WindowIndexGT","product":"core","slug":"tmux-panefilter-windowindexgt"},{"id":"tmux.PaneFilter.WindowIndexGTE","name":"WindowIndexGTE","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndexGTE requires the nonnegative winlink index from Pane.WindowIndex to be greater than or equal to the pointed-to value. A nil pointer leaves WindowIndexGTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":115,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.WindowIndexGTE","product":"core","slug":"tmux-panefilter-windowindexgte"},{"id":"tmux.PaneFilter.WindowIndexLT","name":"WindowIndexLT","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndexLT requires the nonnegative winlink index from Pane.WindowIndex to be strictly less than the pointed-to value. A nil pointer leaves WindowIndexLT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":117,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.WindowIndexLT","product":"core","slug":"tmux-panefilter-windowindexlt"},{"id":"tmux.PaneFilter.WindowIndexLTE","name":"WindowIndexLTE","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndexLTE requires the nonnegative winlink index from Pane.WindowIndex to be less than or equal to the pointed-to value. A nil pointer leaves WindowIndexLTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":119,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.WindowIndexLTE","product":"core","slug":"tmux-panefilter-windowindexlte"},{"id":"tmux.PaneFilter.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"Index exactly matches the nonnegative pane index from Pane.Index. A nil pointer leaves Index unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":121,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Index","product":"core","slug":"tmux-panefilter-index"},{"id":"tmux.PaneFilter.IndexIn","name":"IndexIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]int","doc":{"summary":"IndexIn lists accepted values for the nonnegative pane index from Pane.Index. A candidate matches when its materialized value equals one listed value. A nil slice leaves IndexIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":123,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.IndexIn","product":"core","slug":"tmux-panefilter-indexin"},{"id":"tmux.PaneFilter.IndexGT","name":"IndexGT","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"IndexGT requires the nonnegative pane index from Pane.Index to be strictly greater than the pointed-to value. A nil pointer leaves IndexGT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":125,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.IndexGT","product":"core","slug":"tmux-panefilter-indexgt"},{"id":"tmux.PaneFilter.IndexGTE","name":"IndexGTE","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"IndexGTE requires the nonnegative pane index from Pane.Index to be greater than or equal to the pointed-to value. A nil pointer leaves IndexGTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":127,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.IndexGTE","product":"core","slug":"tmux-panefilter-indexgte"},{"id":"tmux.PaneFilter.IndexLT","name":"IndexLT","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"IndexLT requires the nonnegative pane index from Pane.Index to be strictly less than the pointed-to value. A nil pointer leaves IndexLT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":129,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.IndexLT","product":"core","slug":"tmux-panefilter-indexlt"},{"id":"tmux.PaneFilter.IndexLTE","name":"IndexLTE","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"IndexLTE requires the nonnegative pane index from Pane.Index to be less than or equal to the pointed-to value. A nil pointer leaves IndexLTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":131,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.IndexLTE","product":"core","slug":"tmux-panefilter-indexlte"},{"id":"tmux.PaneFilter.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*string","doc":{"summary":"Command exactly matches the materialized current command from Pane.CurrentCommand. A nil pointer leaves Command unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":133,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Command","product":"core","slug":"tmux-panefilter-command"},{"id":"tmux.PaneFilter.CommandIn","name":"CommandIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]string","doc":{"summary":"CommandIn lists accepted values for the materialized current command from Pane.CurrentCommand. A candidate matches when its materialized value equals one listed value. A nil slice leaves CommandIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":135,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.CommandIn","product":"core","slug":"tmux-panefilter-commandin"},{"id":"tmux.PaneFilter.CommandContains","name":"CommandContains","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*string","doc":{"summary":"CommandContains requires the materialized current command from Pane.CurrentCommand to contain the pointed-to substring. A nil pointer leaves CommandContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":137,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.CommandContains","product":"core","slug":"tmux-panefilter-commandcontains"},{"id":"tmux.PaneFilter.CommandRegex","name":"CommandRegex","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"string","doc":{"summary":"CommandRegex requires the materialized current command from Pane.CurrentCommand to match Go regular expression syntax. An empty string leaves CommandRegex unset."},"source":{"file":"tmux/filter_generated.go","line":139,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.CommandRegex","product":"core","slug":"tmux-panefilter-commandregex"},{"id":"tmux.PaneFilter.Active","name":"Active","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*bool","doc":{"summary":"Active exactly matches the materialized active state from Pane.Active. A nil pointer leaves Active unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":141,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Active","product":"core","slug":"tmux-panefilter-active"},{"id":"tmux.PaneFilter.Title","name":"Title","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*string","doc":{"summary":"Title exactly matches the materialized title from Pane.Title. A nil pointer leaves Title unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":143,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Title","product":"core","slug":"tmux-panefilter-title"},{"id":"tmux.PaneFilter.TitleIn","name":"TitleIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]string","doc":{"summary":"TitleIn lists accepted values for the materialized title from Pane.Title. A candidate matches when its materialized value equals one listed value. A nil slice leaves TitleIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":145,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.TitleIn","product":"core","slug":"tmux-panefilter-titlein"},{"id":"tmux.PaneFilter.TitleContains","name":"TitleContains","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*string","doc":{"summary":"TitleContains requires the materialized title from Pane.Title to contain the pointed-to substring. A nil pointer leaves TitleContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":147,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.TitleContains","product":"core","slug":"tmux-panefilter-titlecontains"},{"id":"tmux.PaneFilter.TitleRegex","name":"TitleRegex","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"string","doc":{"summary":"TitleRegex requires the materialized title from Pane.Title to match Go regular expression syntax. An empty string leaves TitleRegex unset."},"source":{"file":"tmux/filter_generated.go","line":149,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.TitleRegex","product":"core","slug":"tmux-panefilter-titleregex"},{"id":"tmux.PaneFilter.AnyOf","name":"AnyOf","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]PaneFilter","doc":{"summary":"AnyOf additionally requires at least one branch to match after ordinary criteria match. A nil slice leaves AnyOf unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":151,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.AnyOf","product":"core","slug":"tmux-panefilter-anyof"},{"id":"tmux.PaneFilter.Not","name":"Not","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*PaneFilter","doc":{"summary":"Not excludes a candidate when its nested filter matches. A nil pointer leaves Not unset."},"source":{"file":"tmux/filter_generated.go","line":153,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Not","product":"core","slug":"tmux-panefilter-not"},{"id":"tmux.PaneFilter.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*SessionFilter","doc":{"summary":"Session traverses the materialized parent returned by Pane.Session. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":155,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Session","product":"core","slug":"tmux-panefilter-session"},{"id":"tmux.PaneFilter.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*WindowFilter","doc":{"summary":"Window traverses the materialized parent returned by Pane.Window. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":157,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Window","product":"core","slug":"tmux-panefilter-window"},{"id":"tmux.ClientFilter","name":"ClientFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClientFilter matches materialized [Client] values without tmux I/O. Its zero value matches every non-nil candidate. Criteria are ANDed; AnyOf adds an OR requirement and Not excludes. Field and relation criteria correspond to [Client.Name], [Client.ReadOnly], [Client.AttachedSession], [Client.AttachedWindow], and [Client.AttachedPane]. [ClientFilter.Validate] and methods that consume the filter reject invalid criteria with [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":164,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter","product":"core","slug":"tmux-clientfilter"},{"id":"tmux.ClientFilter.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*ClientName","doc":{"summary":"Name exactly matches the stable tmux client name from Client.Name. A nil pointer leaves Name unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":166,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.Name","product":"core","slug":"tmux-clientfilter-name"},{"id":"tmux.ClientFilter.NameIn","name":"NameIn","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"[]ClientName","doc":{"summary":"NameIn lists accepted values for the stable tmux client name from Client.Name. A candidate matches when its materialized value equals one listed value. A nil slice leaves NameIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":168,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.NameIn","product":"core","slug":"tmux-clientfilter-namein"},{"id":"tmux.ClientFilter.NameContains","name":"NameContains","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*string","doc":{"summary":"NameContains requires the stable tmux client name from Client.Name to contain the pointed-to substring. A nil pointer leaves NameContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":170,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.NameContains","product":"core","slug":"tmux-clientfilter-namecontains"},{"id":"tmux.ClientFilter.NameRegex","name":"NameRegex","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"string","doc":{"summary":"NameRegex requires the stable tmux client name from Client.Name to match Go regular expression syntax. An empty string leaves NameRegex unset."},"source":{"file":"tmux/filter_generated.go","line":172,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.NameRegex","product":"core","slug":"tmux-clientfilter-nameregex"},{"id":"tmux.ClientFilter.ReadOnly","name":"ReadOnly","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*bool","doc":{"summary":"ReadOnly exactly matches the materialized read-only state from Client.ReadOnly. A nil pointer leaves ReadOnly unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":174,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.ReadOnly","product":"core","slug":"tmux-clientfilter-readonly"},{"id":"tmux.ClientFilter.AnyOf","name":"AnyOf","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"[]ClientFilter","doc":{"summary":"AnyOf additionally requires at least one branch to match after ordinary criteria match. A nil slice leaves AnyOf unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":176,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.AnyOf","product":"core","slug":"tmux-clientfilter-anyof"},{"id":"tmux.ClientFilter.Not","name":"Not","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*ClientFilter","doc":{"summary":"Not excludes a candidate when its nested filter matches. A nil pointer leaves Not unset."},"source":{"file":"tmux/filter_generated.go","line":178,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.Not","product":"core","slug":"tmux-clientfilter-not"},{"id":"tmux.ClientFilter.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*SessionFilter","doc":{"summary":"Session traverses the materialized attachment returned by Client.AttachedSession. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":180,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.Session","product":"core","slug":"tmux-clientfilter-session"},{"id":"tmux.ClientFilter.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*WindowFilter","doc":{"summary":"Window traverses the materialized attachment returned by Client.AttachedWindow. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":182,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.Window","product":"core","slug":"tmux-clientfilter-window"},{"id":"tmux.ClientFilter.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*PaneFilter","doc":{"summary":"Pane traverses the materialized attachment returned by Client.AttachedPane. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":184,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.Pane","product":"core","slug":"tmux-clientfilter-pane"},{"id":"tmux.SessionIDIs","name":"SessionIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"SessionID"}],"returns":"SessionFilter"}],"doc":{"summary":"SessionIDIs returns a [SessionFilter] that exactly matches the stable tmux session identifier from Session.ID, including its $ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":188,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionIDIs","product":"core","slug":"tmux-sessionidis"},{"id":"tmux.SessionNameIs","name":"SessionNameIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"string"}],"returns":"SessionFilter"}],"doc":{"summary":"SessionNameIs returns a [SessionFilter] that exactly matches the materialized session name from Session.Name. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":193,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionNameIs","product":"core","slug":"tmux-sessionnameis"},{"id":"tmux.SessionAttachedIs","name":"SessionAttachedIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"bool"}],"returns":"SessionFilter"}],"doc":{"summary":"SessionAttachedIs returns a [SessionFilter] that exactly matches the materialized attachment state from Session.Attached. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":198,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionAttachedIs","product":"core","slug":"tmux-sessionattachedis"},{"id":"tmux.WindowSessionIDIs","name":"WindowSessionIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"SessionID"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowSessionIDIs returns a [WindowFilter] that exactly matches the stable tmux session identifier from Window.SessionID, including its $ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":203,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSessionIDIs","product":"core","slug":"tmux-windowsessionidis"},{"id":"tmux.WindowIDIs","name":"WindowIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"WindowID"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowIDIs returns a [WindowFilter] that exactly matches the stable tmux window identifier from Window.ID, including its @ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":208,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowIDIs","product":"core","slug":"tmux-windowidis"},{"id":"tmux.WindowIndexIs","name":"WindowIndexIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"int"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowIndexIs returns a [WindowFilter] that exactly matches the nonnegative winlink index from Window.Index. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":213,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowIndexIs","product":"core","slug":"tmux-windowindexis"},{"id":"tmux.WindowNameIs","name":"WindowNameIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"string"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowNameIs returns a [WindowFilter] that exactly matches the materialized window name from Window.Name. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":218,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowNameIs","product":"core","slug":"tmux-windownameis"},{"id":"tmux.WindowActiveIs","name":"WindowActiveIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"bool"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowActiveIs returns a [WindowFilter] that exactly matches the materialized active state from Window.Active. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":223,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowActiveIs","product":"core","slug":"tmux-windowactiveis"},{"id":"tmux.PaneSessionIDIs","name":"PaneSessionIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"SessionID"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneSessionIDIs returns a [PaneFilter] that exactly matches the stable tmux session identifier from Pane.SessionID, including its $ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":228,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSessionIDIs","product":"core","slug":"tmux-panesessionidis"},{"id":"tmux.PaneWindowIDIs","name":"PaneWindowIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"WindowID"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneWindowIDIs returns a [PaneFilter] that exactly matches the stable tmux window identifier from Pane.WindowID, including its @ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":233,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneWindowIDIs","product":"core","slug":"tmux-panewindowidis"},{"id":"tmux.PaneIDIs","name":"PaneIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"PaneID"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneIDIs returns a [PaneFilter] that exactly matches the stable tmux pane identifier from Pane.ID, including its % sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":238,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneIDIs","product":"core","slug":"tmux-paneidis"},{"id":"tmux.PaneWindowIndexIs","name":"PaneWindowIndexIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"int"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneWindowIndexIs returns a [PaneFilter] that exactly matches the nonnegative winlink index from Pane.WindowIndex. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":243,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneWindowIndexIs","product":"core","slug":"tmux-panewindowindexis"},{"id":"tmux.PaneIndexIs","name":"PaneIndexIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"int"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneIndexIs returns a [PaneFilter] that exactly matches the nonnegative pane index from Pane.Index. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":248,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneIndexIs","product":"core","slug":"tmux-paneindexis"},{"id":"tmux.PaneCommandIs","name":"PaneCommandIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"string"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneCommandIs returns a [PaneFilter] that exactly matches the materialized current command from Pane.CurrentCommand. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":253,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneCommandIs","product":"core","slug":"tmux-panecommandis"},{"id":"tmux.PaneActiveIs","name":"PaneActiveIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"bool"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneActiveIs returns a [PaneFilter] that exactly matches the materialized active state from Pane.Active. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":258,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneActiveIs","product":"core","slug":"tmux-paneactiveis"},{"id":"tmux.PaneTitleIs","name":"PaneTitleIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"string"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneTitleIs returns a [PaneFilter] that exactly matches the materialized title from Pane.Title. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":263,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneTitleIs","product":"core","slug":"tmux-panetitleis"},{"id":"tmux.ClientNameIs","name":"ClientNameIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"ClientName"}],"returns":"ClientFilter"}],"doc":{"summary":"ClientNameIs returns a [ClientFilter] that exactly matches the stable tmux client name from Client.Name. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":268,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientNameIs","product":"core","slug":"tmux-clientnameis"},{"id":"tmux.ClientReadOnlyIs","name":"ClientReadOnlyIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"bool"}],"returns":"ClientFilter"}],"doc":{"summary":"ClientReadOnlyIs returns a [ClientFilter] that exactly matches the materialized read-only state from Client.ReadOnly. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":273,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientReadOnlyIs","product":"core","slug":"tmux-clientreadonlyis"},{"id":"tmux.WindowRel","name":"WindowRel","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowRel applies quantifiers to a materialized [Window] relation; its zero value is invalid. Some is existential, Every is universal and vacuously true for an empty relation, and None excludes; enabled quantifiers are conjunctive."},"source":{"file":"tmux/filter_generated.go","line":279,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowRel","product":"core","slug":"tmux-windowrel"},{"id":"tmux.WindowRel.Some","name":"Some","kind":"attribute","modifiers":[],"parent":"tmux.WindowRel","signatures":[],"type":"*WindowFilter","doc":{"summary":"Some requires an existential match: at least one related value must match."},"source":{"file":"tmux/filter_generated.go","line":281,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowRel.Some","product":"core","slug":"tmux-windowrel-some"},{"id":"tmux.WindowRel.Every","name":"Every","kind":"attribute","modifiers":[],"parent":"tmux.WindowRel","signatures":[],"type":"*WindowFilter","doc":{"summary":"Every requires a universal match and is vacuously true for an empty relation."},"source":{"file":"tmux/filter_generated.go","line":283,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowRel.Every","product":"core","slug":"tmux-windowrel-every"},{"id":"tmux.WindowRel.None","name":"None","kind":"attribute","modifiers":[],"parent":"tmux.WindowRel","signatures":[],"type":"*WindowFilter","doc":{"summary":"None excludes the candidate when any related value matches."},"source":{"file":"tmux/filter_generated.go","line":285,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowRel.None","product":"core","slug":"tmux-windowrel-none"},{"id":"tmux.PaneRel","name":"PaneRel","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneRel applies quantifiers to a materialized [Pane] relation; its zero value is invalid. Some is existential, Every is universal and vacuously true for an empty relation, and None excludes; enabled quantifiers are conjunctive."},"source":{"file":"tmux/filter_generated.go","line":290,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneRel","product":"core","slug":"tmux-panerel"},{"id":"tmux.PaneRel.Some","name":"Some","kind":"attribute","modifiers":[],"parent":"tmux.PaneRel","signatures":[],"type":"*PaneFilter","doc":{"summary":"Some requires an existential match: at least one related value must match."},"source":{"file":"tmux/filter_generated.go","line":292,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneRel.Some","product":"core","slug":"tmux-panerel-some"},{"id":"tmux.PaneRel.Every","name":"Every","kind":"attribute","modifiers":[],"parent":"tmux.PaneRel","signatures":[],"type":"*PaneFilter","doc":{"summary":"Every requires a universal match and is vacuously true for an empty relation."},"source":{"file":"tmux/filter_generated.go","line":294,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneRel.Every","product":"core","slug":"tmux-panerel-every"},{"id":"tmux.PaneRel.None","name":"None","kind":"attribute","modifiers":[],"parent":"tmux.PaneRel","signatures":[],"type":"*PaneFilter","doc":{"summary":"None excludes the candidate when any related value matches."},"source":{"file":"tmux/filter_generated.go","line":296,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneRel.None","product":"core","slug":"tmux-panerel-none"},{"id":"tmux.ParseSessionLookup","name":"ParseSessionLookup","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"lookup","type":"string"},{"name":"values","type":"string"}],"returns":"(SessionFilter, error)"}],"doc":{"summary":"ParseSessionLookup converts a lookup path into a concrete session filter. Paths traverse generated JSON relation names and separate segments with double underscores. The default operator is exact. Accepted suffixes are eq, exact, iexact, contains, icontains, startswith, istartswith, endswith, iendswith, in, nin, regex, and iregex; availability is field-specific. The eq suffix aliases exact, nin negates in, scalar operators require one value, and in and nin require one or more. Invalid paths, operators, values, or results wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":666,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ParseSessionLookup","product":"core","slug":"tmux-parsesessionlookup"},{"id":"tmux.ParseWindowLookup","name":"ParseWindowLookup","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"lookup","type":"string"},{"name":"values","type":"string"}],"returns":"(WindowFilter, error)"}],"doc":{"summary":"ParseWindowLookup converts a lookup path into a concrete window filter. Paths traverse generated JSON relation names and separate segments with double underscores. The default operator is exact. Accepted suffixes are eq, exact, iexact, contains, icontains, startswith, istartswith, endswith, iendswith, in, nin, regex, and iregex; availability is field-specific. The eq suffix aliases exact, nin negates in, scalar operators require one value, and in and nin require one or more. Invalid paths, operators, values, or results wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":690,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ParseWindowLookup","product":"core","slug":"tmux-parsewindowlookup"},{"id":"tmux.ParsePaneLookup","name":"ParsePaneLookup","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"lookup","type":"string"},{"name":"values","type":"string"}],"returns":"(PaneFilter, error)"}],"doc":{"summary":"ParsePaneLookup converts a lookup path into a concrete pane filter. Paths traverse generated JSON relation names and separate segments with double underscores. The default operator is exact. Accepted suffixes are eq, exact, iexact, contains, icontains, startswith, istartswith, endswith, iendswith, in, nin, regex, and iregex; availability is field-specific. The eq suffix aliases exact, nin negates in, scalar operators require one value, and in and nin require one or more. Invalid paths, operators, values, or results wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":714,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ParsePaneLookup","product":"core","slug":"tmux-parsepanelookup"},{"id":"tmux.ParseClientLookup","name":"ParseClientLookup","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"lookup","type":"string"},{"name":"values","type":"string"}],"returns":"(ClientFilter, error)"}],"doc":{"summary":"ParseClientLookup converts a lookup path into a concrete client filter. Paths traverse generated JSON relation names and separate segments with double underscores. The default operator is exact. Accepted suffixes are eq, exact, iexact, contains, icontains, startswith, istartswith, endswith, iendswith, in, nin, regex, and iregex; availability is field-specific. The eq suffix aliases exact, nin negates in, scalar operators require one value, and in and nin require one or more. Invalid paths, operators, values, or results wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":738,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ParseClientLookup","product":"core","slug":"tmux-parseclientlookup"},{"id":"tmux.SessionFilter.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.SessionFilter","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks structure, regular expressions, and contradictory criteria; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":1687,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.Validate","product":"core","slug":"tmux-sessionfilter-validate"},{"id":"tmux.WindowFilter.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.WindowFilter","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks structure, regular expressions, and contradictory criteria; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":1907,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.Validate","product":"core","slug":"tmux-windowfilter-validate"},{"id":"tmux.PaneFilter.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.PaneFilter","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks structure, regular expressions, and contradictory criteria; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2093,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Validate","product":"core","slug":"tmux-panefilter-validate"},{"id":"tmux.ClientFilter.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.ClientFilter","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks structure, regular expressions, and contradictory criteria; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2256,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.Validate","product":"core","slug":"tmux-clientfilter-validate"},{"id":"tmux.SessionFilter.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.SessionFilter","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the session filter; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2387,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.MarshalJSON","product":"core","slug":"tmux-sessionfilter-marshaljson"},{"id":"tmux.WindowFilter.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.WindowFilter","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the window filter; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2396,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.MarshalJSON","product":"core","slug":"tmux-windowfilter-marshaljson"},{"id":"tmux.PaneFilter.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.PaneFilter","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the pane filter; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2405,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.MarshalJSON","product":"core","slug":"tmux-panefilter-marshaljson"},{"id":"tmux.ClientFilter.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.ClientFilter","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the client filter; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2414,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.MarshalJSON","product":"core","slug":"tmux-clientfilter-marshaljson"},{"id":"tmux.WindowRel.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.WindowRel","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the window relation; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2445,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowRel.MarshalJSON","product":"core","slug":"tmux-windowrel-marshaljson"},{"id":"tmux.PaneRel.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.PaneRel","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the pane relation; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2476,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneRel.MarshalJSON","product":"core","slug":"tmux-panerel-marshaljson"},{"id":"tmux.SessionFilter.Predicate","name":"Predicate","kind":"method","modifiers":[],"parent":"tmux.SessionFilter","signatures":[{"params":[],"returns":"(func(*Session) bool, error)"}],"doc":{"summary":"Predicate validates the session filter and returns a local predicate for [Session] values materialized by a [Snapshot]; it never runs tmux. It traverses only loaded relations and returns false for a nil candidate."},"source":{"file":"tmux/filter_generated.go","line":2486,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.Predicate","product":"core","slug":"tmux-sessionfilter-predicate"},{"id":"tmux.WindowFilter.Predicate","name":"Predicate","kind":"method","modifiers":[],"parent":"tmux.WindowFilter","signatures":[{"params":[],"returns":"(func(*Window) bool, error)"}],"doc":{"summary":"Predicate validates the window filter and returns a local predicate for [Window] values materialized by a [Snapshot]; it never runs tmux. It traverses only loaded relations and returns false for a nil candidate."},"source":{"file":"tmux/filter_generated.go","line":2720,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.Predicate","product":"core","slug":"tmux-windowfilter-predicate"},{"id":"tmux.PaneFilter.Predicate","name":"Predicate","kind":"method","modifiers":[],"parent":"tmux.PaneFilter","signatures":[{"params":[],"returns":"(func(*Pane) bool, error)"}],"doc":{"summary":"Predicate validates the pane filter and returns a local predicate for [Pane] values materialized by a [Snapshot]; it never runs tmux. It traverses only loaded relations and returns false for a nil candidate."},"source":{"file":"tmux/filter_generated.go","line":2979,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.Predicate","product":"core","slug":"tmux-panefilter-predicate"},{"id":"tmux.ClientFilter.Predicate","name":"Predicate","kind":"method","modifiers":[],"parent":"tmux.ClientFilter","signatures":[{"params":[],"returns":"(func(*Client) bool, error)"}],"doc":{"summary":"Predicate validates the client filter and returns a local predicate for [Client] values materialized by a [Snapshot]; it never runs tmux. It traverses only loaded relations and returns false for a nil candidate."},"source":{"file":"tmux/filter_generated.go","line":3304,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.Predicate","product":"core","slug":"tmux-clientfilter-predicate"},{"id":"tmux.SessionFilter.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.SessionFilter","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a session filter, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3446,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFilter.UnmarshalJSON","product":"core","slug":"tmux-sessionfilter-unmarshaljson"},{"id":"tmux.WindowFilter.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.WindowFilter","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a window filter, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3471,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFilter.UnmarshalJSON","product":"core","slug":"tmux-windowfilter-unmarshaljson"},{"id":"tmux.PaneFilter.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.PaneFilter","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a pane filter, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3504,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFilter.UnmarshalJSON","product":"core","slug":"tmux-panefilter-unmarshaljson"},{"id":"tmux.ClientFilter.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.ClientFilter","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a client filter, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3549,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientFilter.UnmarshalJSON","product":"core","slug":"tmux-clientfilter-unmarshaljson"},{"id":"tmux.WindowRel.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.WindowRel","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a window relation, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3573,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowRel.UnmarshalJSON","product":"core","slug":"tmux-windowrel-unmarshaljson"},{"id":"tmux.PaneRel.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.PaneRel","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a pane relation, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3590,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneRel.UnmarshalJSON","product":"core","slug":"tmux-panerel-unmarshaljson"},{"id":"tmux.ErrMalformedFormatOutput","name":"ErrMalformedFormatOutput","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedFormatOutput identifies invalid escaped tmux format output. It is matched by errors.Is for [FormatDecodeError]."},"source":{"file":"tmux/format.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrMalformedFormatOutput","product":"core","slug":"tmux-errmalformedformatoutput"},{"id":"tmux.FormatDecodeError","name":"FormatDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"FormatDecodeError identifies a malformed escaped tmux format record. It matches [ErrMalformedFormatOutput] through errors.Is; callers can recover its location fields with errors.As. Library-created errors do not retain decoded record values, which may contain caller data."},"source":{"file":"tmux/format.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatDecodeError","product":"core","slug":"tmux-formatdecodeerror"},{"id":"tmux.FormatDecodeError.Record","name":"Record","kind":"attribute","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[],"type":"int","doc":{"summary":"Record is the one-based physical record number."},"source":{"file":"tmux/format.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatDecodeError.Record","product":"core","slug":"tmux-formatdecodeerror-record"},{"id":"tmux.FormatDecodeError.Field","name":"Field","kind":"attribute","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[],"type":"string","doc":{"summary":"Field names the format field that could not be decoded."},"source":{"file":"tmux/format.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatDecodeError.Field","product":"core","slug":"tmux-formatdecodeerror-field"},{"id":"tmux.FormatDecodeError.Offset","name":"Offset","kind":"attribute","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[],"type":"int","doc":{"summary":"Offset is the zero-based byte offset within Field's encoded value."},"source":{"file":"tmux/format.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatDecodeError.Offset","product":"core","slug":"tmux-formatdecodeerror-offset"},{"id":"tmux.FormatDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes the malformed encoding."},"source":{"file":"tmux/format.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatDecodeError.Reason","product":"core","slug":"tmux-formatdecodeerror-reason"},{"id":"tmux.FormatDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/format.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatDecodeError.Error","product":"core","slug":"tmux-formatdecodeerror-error"},{"id":"tmux.FormatDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes FormatDecodeError compatible with ErrMalformedFormatOutput."},"source":{"file":"tmux/format.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatDecodeError.Unwrap","product":"core","slug":"tmux-formatdecodeerror-unwrap"},{"id":"tmux.FormatValues","name":"FormatValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"FormatValues is a read-only view of format expansions materialized with a Session, Window, Pane, or Client. Its methods do not query tmux. Projected cross-scope fields do not imply that the referenced record was materialized.","body":"Typed accessors return ok == false for an absent, empty, or malformed value;\n[FormatValues.Raw] distinguishes absent from present empty expansions. The\nzero value reports every field as absent."},"source":{"file":"tmux/format.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues","product":"core","slug":"tmux-formatvalues"},{"id":"tmux.FormatValues.Raw","name":"Raw","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(string, bool)"}],"doc":{"summary":"Raw returns the exact materialized tmux format expansion for name. It never queries tmux; ok distinguishes an absent field from a present empty value."},"source":{"file":"tmux/format.go","line":226,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.Raw","product":"core","slug":"tmux-formatvalues-raw"},{"id":"tmux.Session.Formats","name":"Formats","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"FormatValues"}],"doc":{"summary":"Formats returns this Session's read-only materialized tmux format values. It does not query tmux; use [Server.Snapshot] to obtain a fresh record."},"source":{"file":"tmux/format.go","line":232,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Formats","product":"core","slug":"tmux-session-formats"},{"id":"tmux.Window.Formats","name":"Formats","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"FormatValues"}],"doc":{"summary":"Formats returns this Window's read-only materialized tmux format values. It does not query tmux; use [Server.Snapshot] to obtain a fresh record."},"source":{"file":"tmux/format.go","line":238,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Formats","product":"core","slug":"tmux-window-formats"},{"id":"tmux.Pane.Formats","name":"Formats","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"FormatValues"}],"doc":{"summary":"Formats returns this Pane's read-only materialized tmux format values. It does not query tmux; use [Server.Snapshot] to obtain a fresh record."},"source":{"file":"tmux/format.go","line":244,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Formats","product":"core","slug":"tmux-pane-formats"},{"id":"tmux.Client.Formats","name":"Formats","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"FormatValues"}],"doc":{"summary":"Formats returns this Client's read-only materialized tmux format values. It does not query tmux; use [Server.Snapshot] to obtain a fresh record."},"source":{"file":"tmux/format.go","line":250,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Formats","product":"core","slug":"tmux-client-formats"},{"id":"tmux.FormatValues.ActiveWindowIndex","name":"ActiveWindowIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ActiveWindowIndex returns tmux #{active_window_index} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":223,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ActiveWindowIndex","product":"core","slug":"tmux-formatvalues-activewindowindex"},{"id":"tmux.FormatValues.AlternateOn","name":"AlternateOn","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AlternateOn returns tmux #{alternate_on} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":226,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.AlternateOn","product":"core","slug":"tmux-formatvalues-alternateon"},{"id":"tmux.FormatValues.AlternateSavedX","name":"AlternateSavedX","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"AlternateSavedX returns tmux #{alternate_saved_x} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":229,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.AlternateSavedX","product":"core","slug":"tmux-formatvalues-alternatesavedx"},{"id":"tmux.FormatValues.AlternateSavedY","name":"AlternateSavedY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"AlternateSavedY returns tmux #{alternate_saved_y} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":232,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.AlternateSavedY","product":"core","slug":"tmux-formatvalues-alternatesavedy"},{"id":"tmux.FormatValues.BracketPasteFlag","name":"BracketPasteFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"BracketPasteFlag returns tmux #{bracket_paste_flag} as bool from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":235,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.BracketPasteFlag","product":"core","slug":"tmux-formatvalues-bracketpasteflag"},{"id":"tmux.FormatValues.BufferModeFormat","name":"BufferModeFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"BufferModeFormat returns tmux #{buffer_mode_format} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":238,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.BufferModeFormat","product":"core","slug":"tmux-formatvalues-buffermodeformat"},{"id":"tmux.FormatValues.ClientActivity","name":"ClientActivity","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"ClientActivity returns tmux #{client_activity} as time.Time from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":243,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientActivity","product":"core","slug":"tmux-formatvalues-clientactivity"},{"id":"tmux.FormatValues.ClientCellHeight","name":"ClientCellHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientCellHeight returns tmux #{client_cell_height} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":246,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientCellHeight","product":"core","slug":"tmux-formatvalues-clientcellheight"},{"id":"tmux.FormatValues.ClientCellWidth","name":"ClientCellWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientCellWidth returns tmux #{client_cell_width} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":249,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientCellWidth","product":"core","slug":"tmux-formatvalues-clientcellwidth"},{"id":"tmux.FormatValues.ClientControlMode","name":"ClientControlMode","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ClientControlMode returns tmux #{client_control_mode} as bool from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":252,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientControlMode","product":"core","slug":"tmux-formatvalues-clientcontrolmode"},{"id":"tmux.FormatValues.ClientCreated","name":"ClientCreated","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"ClientCreated returns tmux #{client_created} as time.Time from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":257,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientCreated","product":"core","slug":"tmux-formatvalues-clientcreated"},{"id":"tmux.FormatValues.ClientDiscarded","name":"ClientDiscarded","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientDiscarded returns tmux #{client_discarded} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":260,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientDiscarded","product":"core","slug":"tmux-formatvalues-clientdiscarded"},{"id":"tmux.FormatValues.ClientFlags","name":"ClientFlags","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientFlags returns tmux #{client_flags} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":263,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientFlags","product":"core","slug":"tmux-formatvalues-clientflags"},{"id":"tmux.FormatValues.ClientHeight","name":"ClientHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientHeight returns tmux #{client_height} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":266,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientHeight","product":"core","slug":"tmux-formatvalues-clientheight"},{"id":"tmux.FormatValues.ClientKeyTable","name":"ClientKeyTable","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientKeyTable returns tmux #{client_key_table} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":269,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientKeyTable","product":"core","slug":"tmux-formatvalues-clientkeytable"},{"id":"tmux.FormatValues.ClientLastSession","name":"ClientLastSession","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientLastSession returns tmux #{client_last_session} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":272,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientLastSession","product":"core","slug":"tmux-formatvalues-clientlastsession"},{"id":"tmux.FormatValues.ClientModeFormat","name":"ClientModeFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientModeFormat returns tmux #{client_mode_format} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":277,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientModeFormat","product":"core","slug":"tmux-formatvalues-clientmodeformat"},{"id":"tmux.FormatValues.ClientName","name":"ClientName","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(ClientName, bool)"}],"doc":{"summary":"ClientName returns tmux #{client_name} as ClientName from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":282,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientName","product":"core","slug":"tmux-formatvalues-clientname"},{"id":"tmux.FormatValues.ClientPID","name":"ClientPID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientPID returns tmux #{client_pid} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":285,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientPID","product":"core","slug":"tmux-formatvalues-clientpid"},{"id":"tmux.FormatValues.ClientPrefix","name":"ClientPrefix","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ClientPrefix returns tmux #{client_prefix} as bool from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":288,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientPrefix","product":"core","slug":"tmux-formatvalues-clientprefix"},{"id":"tmux.FormatValues.ClientReadOnly","name":"ClientReadOnly","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ClientReadOnly returns tmux #{client_readonly} as bool from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":291,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientReadOnly","product":"core","slug":"tmux-formatvalues-clientreadonly"},{"id":"tmux.FormatValues.ClientSession","name":"ClientSession","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientSession returns tmux #{client_session} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":294,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientSession","product":"core","slug":"tmux-formatvalues-clientsession"},{"id":"tmux.FormatValues.ClientTermFeatures","name":"ClientTermFeatures","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientTermFeatures returns tmux #{client_termfeatures} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":297,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientTermFeatures","product":"core","slug":"tmux-formatvalues-clienttermfeatures"},{"id":"tmux.FormatValues.ClientTermName","name":"ClientTermName","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientTermName returns tmux #{client_termname} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":302,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientTermName","product":"core","slug":"tmux-formatvalues-clienttermname"},{"id":"tmux.FormatValues.ClientTermType","name":"ClientTermType","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientTermType returns tmux #{client_termtype} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":305,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientTermType","product":"core","slug":"tmux-formatvalues-clienttermtype"},{"id":"tmux.FormatValues.ClientTTY","name":"ClientTTY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientTTY returns tmux #{client_tty} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":308,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientTTY","product":"core","slug":"tmux-formatvalues-clienttty"},{"id":"tmux.FormatValues.ClientUID","name":"ClientUID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientUID returns tmux #{client_uid} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":311,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientUID","product":"core","slug":"tmux-formatvalues-clientuid"},{"id":"tmux.FormatValues.ClientUser","name":"ClientUser","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientUser returns tmux #{client_user} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":314,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientUser","product":"core","slug":"tmux-formatvalues-clientuser"},{"id":"tmux.FormatValues.ClientUTF8","name":"ClientUTF8","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ClientUTF8 returns tmux #{client_utf8} as bool from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":317,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientUTF8","product":"core","slug":"tmux-formatvalues-clientutf8"},{"id":"tmux.FormatValues.ClientWidth","name":"ClientWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientWidth returns tmux #{client_width} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":320,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientWidth","product":"core","slug":"tmux-formatvalues-clientwidth"},{"id":"tmux.FormatValues.ClientWritten","name":"ClientWritten","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientWritten returns tmux #{client_written} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":323,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ClientWritten","product":"core","slug":"tmux-formatvalues-clientwritten"},{"id":"tmux.FormatValues.ConfigFiles","name":"ConfigFiles","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ConfigFiles returns tmux #{config_files} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":326,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ConfigFiles","product":"core","slug":"tmux-formatvalues-configfiles"},{"id":"tmux.FormatValues.CursorBlinking","name":"CursorBlinking","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorBlinking returns tmux #{cursor_blinking} as bool from materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":329,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.CursorBlinking","product":"core","slug":"tmux-formatvalues-cursorblinking"},{"id":"tmux.FormatValues.CursorCharacter","name":"CursorCharacter","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorCharacter returns tmux #{cursor_character} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":332,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.CursorCharacter","product":"core","slug":"tmux-formatvalues-cursorcharacter"},{"id":"tmux.FormatValues.CursorColour","name":"CursorColour","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorColour returns tmux #{cursor_colour} as string from materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":335,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.CursorColour","product":"core","slug":"tmux-formatvalues-cursorcolour"},{"id":"tmux.FormatValues.CursorFlag","name":"CursorFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorFlag returns tmux #{cursor_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":338,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.CursorFlag","product":"core","slug":"tmux-formatvalues-cursorflag"},{"id":"tmux.FormatValues.CursorShape","name":"CursorShape","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorShape returns tmux #{cursor_shape} as string from materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":341,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.CursorShape","product":"core","slug":"tmux-formatvalues-cursorshape"},{"id":"tmux.FormatValues.CursorVeryVisible","name":"CursorVeryVisible","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorVeryVisible returns tmux #{cursor_very_visible} as bool from materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":344,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.CursorVeryVisible","product":"core","slug":"tmux-formatvalues-cursorveryvisible"},{"id":"tmux.FormatValues.CursorX","name":"CursorX","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CursorX returns tmux #{cursor_x} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":349,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.CursorX","product":"core","slug":"tmux-formatvalues-cursorx"},{"id":"tmux.FormatValues.CursorY","name":"CursorY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CursorY returns tmux #{cursor_y} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":352,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.CursorY","product":"core","slug":"tmux-formatvalues-cursory"},{"id":"tmux.FormatValues.HistoryAdded","name":"HistoryAdded","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryAdded returns tmux #{history_added} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":355,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.HistoryAdded","product":"core","slug":"tmux-formatvalues-historyadded"},{"id":"tmux.FormatValues.HistoryAllBytes","name":"HistoryAllBytes","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"HistoryAllBytes returns tmux #{history_all_bytes} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":358,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.HistoryAllBytes","product":"core","slug":"tmux-formatvalues-historyallbytes"},{"id":"tmux.FormatValues.HistoryBytes","name":"HistoryBytes","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryBytes returns tmux #{history_bytes} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":363,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.HistoryBytes","product":"core","slug":"tmux-formatvalues-historybytes"},{"id":"tmux.FormatValues.HistoryCollected","name":"HistoryCollected","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryCollected returns tmux #{history_collected} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":366,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.HistoryCollected","product":"core","slug":"tmux-formatvalues-historycollected"},{"id":"tmux.FormatValues.HistoryGeneration","name":"HistoryGeneration","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryGeneration returns tmux #{history_generation} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":369,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.HistoryGeneration","product":"core","slug":"tmux-formatvalues-historygeneration"},{"id":"tmux.FormatValues.HistoryLimit","name":"HistoryLimit","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryLimit returns tmux #{history_limit} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":372,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.HistoryLimit","product":"core","slug":"tmux-formatvalues-historylimit"},{"id":"tmux.FormatValues.HistorySize","name":"HistorySize","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistorySize returns tmux #{history_size} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":375,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.HistorySize","product":"core","slug":"tmux-formatvalues-historysize"},{"id":"tmux.FormatValues.Host","name":"Host","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Host returns tmux #{host} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":378,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.Host","product":"core","slug":"tmux-formatvalues-host"},{"id":"tmux.FormatValues.HostShort","name":"HostShort","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"HostShort returns tmux #{host_short} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":381,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.HostShort","product":"core","slug":"tmux-formatvalues-hostshort"},{"id":"tmux.FormatValues.InsertFlag","name":"InsertFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"InsertFlag returns tmux #{insert_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":384,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.InsertFlag","product":"core","slug":"tmux-formatvalues-insertflag"},{"id":"tmux.FormatValues.KeypadCursorFlag","name":"KeypadCursorFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"KeypadCursorFlag returns tmux #{keypad_cursor_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":387,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.KeypadCursorFlag","product":"core","slug":"tmux-formatvalues-keypadcursorflag"},{"id":"tmux.FormatValues.KeypadFlag","name":"KeypadFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"KeypadFlag returns tmux #{keypad_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":390,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.KeypadFlag","product":"core","slug":"tmux-formatvalues-keypadflag"},{"id":"tmux.FormatValues.LastWindowIndex","name":"LastWindowIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"LastWindowIndex returns tmux #{last_window_index} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":393,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.LastWindowIndex","product":"core","slug":"tmux-formatvalues-lastwindowindex"},{"id":"tmux.FormatValues.Line","name":"Line","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Line returns tmux #{line} as int from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":396,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.Line","product":"core","slug":"tmux-formatvalues-line"},{"id":"tmux.FormatValues.MouseAllFlag","name":"MouseAllFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseAllFlag returns tmux #{mouse_all_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":399,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.MouseAllFlag","product":"core","slug":"tmux-formatvalues-mouseallflag"},{"id":"tmux.FormatValues.MouseAnyFlag","name":"MouseAnyFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseAnyFlag returns tmux #{mouse_any_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":402,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.MouseAnyFlag","product":"core","slug":"tmux-formatvalues-mouseanyflag"},{"id":"tmux.FormatValues.MouseButtonFlag","name":"MouseButtonFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseButtonFlag returns tmux #{mouse_button_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":405,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.MouseButtonFlag","product":"core","slug":"tmux-formatvalues-mousebuttonflag"},{"id":"tmux.FormatValues.MouseSGRFlag","name":"MouseSGRFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseSGRFlag returns tmux #{mouse_sgr_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":408,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.MouseSGRFlag","product":"core","slug":"tmux-formatvalues-mousesgrflag"},{"id":"tmux.FormatValues.MouseStandardFlag","name":"MouseStandardFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseStandardFlag returns tmux #{mouse_standard_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":411,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.MouseStandardFlag","product":"core","slug":"tmux-formatvalues-mousestandardflag"},{"id":"tmux.FormatValues.MouseUTF8Flag","name":"MouseUTF8Flag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseUTF8Flag returns tmux #{mouse_utf8_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":416,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.MouseUTF8Flag","product":"core","slug":"tmux-formatvalues-mouseutf8flag"},{"id":"tmux.FormatValues.NextSessionID","name":"NextSessionID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(SessionID, bool)"}],"doc":{"summary":"NextSessionID returns tmux #{next_session_id} as SessionID from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":419,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.NextSessionID","product":"core","slug":"tmux-formatvalues-nextsessionid"},{"id":"tmux.FormatValues.OriginFlag","name":"OriginFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"OriginFlag returns tmux #{origin_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":424,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.OriginFlag","product":"core","slug":"tmux-formatvalues-originflag"},{"id":"tmux.FormatValues.PaneActive","name":"PaneActive","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneActive returns tmux #{pane_active} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":427,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneActive","product":"core","slug":"tmux-formatvalues-paneactive"},{"id":"tmux.FormatValues.PaneAtBottom","name":"PaneAtBottom","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneAtBottom returns tmux #{pane_at_bottom} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":430,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneAtBottom","product":"core","slug":"tmux-formatvalues-paneatbottom"},{"id":"tmux.FormatValues.PaneAtLeft","name":"PaneAtLeft","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneAtLeft returns tmux #{pane_at_left} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":433,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneAtLeft","product":"core","slug":"tmux-formatvalues-paneatleft"},{"id":"tmux.FormatValues.PaneAtRight","name":"PaneAtRight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneAtRight returns tmux #{pane_at_right} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":436,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneAtRight","product":"core","slug":"tmux-formatvalues-paneatright"},{"id":"tmux.FormatValues.PaneAtTop","name":"PaneAtTop","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneAtTop returns tmux #{pane_at_top} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":439,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneAtTop","product":"core","slug":"tmux-formatvalues-paneattop"},{"id":"tmux.FormatValues.PaneBG","name":"PaneBG","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneBG returns tmux #{pane_bg} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":442,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneBG","product":"core","slug":"tmux-formatvalues-panebg"},{"id":"tmux.FormatValues.PaneBottom","name":"PaneBottom","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneBottom returns tmux #{pane_bottom} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":445,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneBottom","product":"core","slug":"tmux-formatvalues-panebottom"},{"id":"tmux.FormatValues.PaneCommandRunning","name":"PaneCommandRunning","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneCommandRunning returns tmux #{pane_command_running} as bool from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":448,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneCommandRunning","product":"core","slug":"tmux-formatvalues-panecommandrunning"},{"id":"tmux.FormatValues.PaneCurrentCommand","name":"PaneCurrentCommand","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneCurrentCommand returns tmux #{pane_current_command} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":453,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneCurrentCommand","product":"core","slug":"tmux-formatvalues-panecurrentcommand"},{"id":"tmux.FormatValues.PaneCurrentPath","name":"PaneCurrentPath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneCurrentPath returns tmux #{pane_current_path} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":458,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneCurrentPath","product":"core","slug":"tmux-formatvalues-panecurrentpath"},{"id":"tmux.FormatValues.PaneDead","name":"PaneDead","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneDead returns tmux #{pane_dead} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":463,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneDead","product":"core","slug":"tmux-formatvalues-panedead"},{"id":"tmux.FormatValues.PaneDeadSignal","name":"PaneDeadSignal","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneDeadSignal returns tmux #{pane_dead_signal} as string from materialized pane-scoped fields (tmux 3.3 or later)."},"source":{"file":"tmux/format_generated.go","line":466,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneDeadSignal","product":"core","slug":"tmux-formatvalues-panedeadsignal"},{"id":"tmux.FormatValues.PaneDeadStatus","name":"PaneDeadStatus","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneDeadStatus returns tmux #{pane_dead_status} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":469,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneDeadStatus","product":"core","slug":"tmux-formatvalues-panedeadstatus"},{"id":"tmux.FormatValues.PaneDeadTime","name":"PaneDeadTime","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"PaneDeadTime returns tmux #{pane_dead_time} as time.Time from materialized pane-scoped fields (tmux 3.3 or later)."},"source":{"file":"tmux/format_generated.go","line":472,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneDeadTime","product":"core","slug":"tmux-formatvalues-panedeadtime"},{"id":"tmux.FormatValues.PaneFG","name":"PaneFG","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneFG returns tmux #{pane_fg} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":475,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneFG","product":"core","slug":"tmux-formatvalues-panefg"},{"id":"tmux.FormatValues.PaneFlags","name":"PaneFlags","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneFlags returns tmux #{pane_flags} as string from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":478,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneFlags","product":"core","slug":"tmux-formatvalues-paneflags"},{"id":"tmux.FormatValues.PaneFloatingFlag","name":"PaneFloatingFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneFloatingFlag returns tmux #{pane_floating_flag} as bool from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":481,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneFloatingFlag","product":"core","slug":"tmux-formatvalues-panefloatingflag"},{"id":"tmux.FormatValues.PaneFormat","name":"PaneFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneFormat returns tmux #{pane_format} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":484,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneFormat","product":"core","slug":"tmux-formatvalues-paneformat"},{"id":"tmux.FormatValues.PaneHeight","name":"PaneHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneHeight returns tmux #{pane_height} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":487,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneHeight","product":"core","slug":"tmux-formatvalues-paneheight"},{"id":"tmux.FormatValues.PaneID","name":"PaneID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(PaneID, bool)"}],"doc":{"summary":"PaneID returns tmux #{pane_id} as PaneID from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":490,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneID","product":"core","slug":"tmux-formatvalues-paneid"},{"id":"tmux.FormatValues.PaneInMode","name":"PaneInMode","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneInMode returns tmux #{pane_in_mode} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":493,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneInMode","product":"core","slug":"tmux-formatvalues-paneinmode"},{"id":"tmux.FormatValues.PaneIndex","name":"PaneIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneIndex returns tmux #{pane_index} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":496,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneIndex","product":"core","slug":"tmux-formatvalues-paneindex"},{"id":"tmux.FormatValues.PaneInputOff","name":"PaneInputOff","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneInputOff returns tmux #{pane_input_off} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":499,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneInputOff","product":"core","slug":"tmux-formatvalues-paneinputoff"},{"id":"tmux.FormatValues.PaneKeyMode","name":"PaneKeyMode","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneKeyMode returns tmux #{pane_key_mode} as string from materialized pane-scoped fields (tmux 3.5 or later)."},"source":{"file":"tmux/format_generated.go","line":502,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneKeyMode","product":"core","slug":"tmux-formatvalues-panekeymode"},{"id":"tmux.FormatValues.PaneLast","name":"PaneLast","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneLast returns tmux #{pane_last} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":505,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneLast","product":"core","slug":"tmux-formatvalues-panelast"},{"id":"tmux.FormatValues.PaneLeft","name":"PaneLeft","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneLeft returns tmux #{pane_left} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":508,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneLeft","product":"core","slug":"tmux-formatvalues-paneleft"},{"id":"tmux.FormatValues.PaneMarked","name":"PaneMarked","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneMarked returns tmux #{pane_marked} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":511,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneMarked","product":"core","slug":"tmux-formatvalues-panemarked"},{"id":"tmux.FormatValues.PaneMarkedSet","name":"PaneMarkedSet","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneMarkedSet returns tmux #{pane_marked_set} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":514,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneMarkedSet","product":"core","slug":"tmux-formatvalues-panemarkedset"},{"id":"tmux.FormatValues.PaneModalFlag","name":"PaneModalFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneModalFlag returns tmux #{pane_modal_flag} as bool from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":517,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneModalFlag","product":"core","slug":"tmux-formatvalues-panemodalflag"},{"id":"tmux.FormatValues.PaneMode","name":"PaneMode","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneMode returns tmux #{pane_mode} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":520,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneMode","product":"core","slug":"tmux-formatvalues-panemode"},{"id":"tmux.FormatValues.PaneOutputGeneration","name":"PaneOutputGeneration","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneOutputGeneration returns tmux #{pane_output_generation} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":523,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneOutputGeneration","product":"core","slug":"tmux-formatvalues-paneoutputgeneration"},{"id":"tmux.FormatValues.PanePath","name":"PanePath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PanePath returns tmux #{pane_path} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":528,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PanePath","product":"core","slug":"tmux-formatvalues-panepath"},{"id":"tmux.FormatValues.PanePBProgress","name":"PanePBProgress","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PanePBProgress returns tmux #{pane_pb_progress} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":531,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PanePBProgress","product":"core","slug":"tmux-formatvalues-panepbprogress"},{"id":"tmux.FormatValues.PanePBState","name":"PanePBState","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PanePBState returns tmux #{pane_pb_state} as string from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":534,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PanePBState","product":"core","slug":"tmux-formatvalues-panepbstate"},{"id":"tmux.FormatValues.PanePID","name":"PanePID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PanePID returns tmux #{pane_pid} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":537,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PanePID","product":"core","slug":"tmux-formatvalues-panepid"},{"id":"tmux.FormatValues.PanePipe","name":"PanePipe","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PanePipe returns tmux #{pane_pipe} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":540,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PanePipe","product":"core","slug":"tmux-formatvalues-panepipe"},{"id":"tmux.FormatValues.PanePipePID","name":"PanePipePID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PanePipePID returns tmux #{pane_pipe_pid} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":543,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PanePipePID","product":"core","slug":"tmux-formatvalues-panepipepid"},{"id":"tmux.FormatValues.PanePrivateModes","name":"PanePrivateModes","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PanePrivateModes returns tmux #{pane_private_modes} as string from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":546,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PanePrivateModes","product":"core","slug":"tmux-formatvalues-paneprivatemodes"},{"id":"tmux.FormatValues.PaneRight","name":"PaneRight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneRight returns tmux #{pane_right} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":551,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneRight","product":"core","slug":"tmux-formatvalues-paneright"},{"id":"tmux.FormatValues.PaneSearchString","name":"PaneSearchString","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneSearchString returns tmux #{pane_search_string} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":554,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneSearchString","product":"core","slug":"tmux-formatvalues-panesearchstring"},{"id":"tmux.FormatValues.PaneStartCommand","name":"PaneStartCommand","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneStartCommand returns tmux #{pane_start_command} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":559,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneStartCommand","product":"core","slug":"tmux-formatvalues-panestartcommand"},{"id":"tmux.FormatValues.PaneStartCommandList","name":"PaneStartCommandList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneStartCommandList returns tmux #{pane_start_command_list} as string from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":564,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneStartCommandList","product":"core","slug":"tmux-formatvalues-panestartcommandlist"},{"id":"tmux.FormatValues.PaneStartPath","name":"PaneStartPath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneStartPath returns tmux #{pane_start_path} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":569,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneStartPath","product":"core","slug":"tmux-formatvalues-panestartpath"},{"id":"tmux.FormatValues.PaneSynchronized","name":"PaneSynchronized","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneSynchronized returns tmux #{pane_synchronized} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":572,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneSynchronized","product":"core","slug":"tmux-formatvalues-panesynchronized"},{"id":"tmux.FormatValues.PaneTabs","name":"PaneTabs","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneTabs returns tmux #{pane_tabs} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":575,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneTabs","product":"core","slug":"tmux-formatvalues-panetabs"},{"id":"tmux.FormatValues.PaneTitle","name":"PaneTitle","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneTitle returns tmux #{pane_title} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":578,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneTitle","product":"core","slug":"tmux-formatvalues-panetitle"},{"id":"tmux.FormatValues.PaneTop","name":"PaneTop","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneTop returns tmux #{pane_top} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":581,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneTop","product":"core","slug":"tmux-formatvalues-panetop"},{"id":"tmux.FormatValues.PaneTTY","name":"PaneTTY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneTTY returns tmux #{pane_tty} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":584,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneTTY","product":"core","slug":"tmux-formatvalues-panetty"},{"id":"tmux.FormatValues.PaneUnseenChanges","name":"PaneUnseenChanges","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneUnseenChanges returns tmux #{pane_unseen_changes} as bool from materialized pane-scoped fields (tmux 3.4 or later)."},"source":{"file":"tmux/format_generated.go","line":587,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneUnseenChanges","product":"core","slug":"tmux-formatvalues-paneunseenchanges"},{"id":"tmux.FormatValues.PaneUnzoomedHeight","name":"PaneUnzoomedHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneUnzoomedHeight returns tmux #{pane_unzoomed_height} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":592,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneUnzoomedHeight","product":"core","slug":"tmux-formatvalues-paneunzoomedheight"},{"id":"tmux.FormatValues.PaneUnzoomedWidth","name":"PaneUnzoomedWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneUnzoomedWidth returns tmux #{pane_unzoomed_width} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":597,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneUnzoomedWidth","product":"core","slug":"tmux-formatvalues-paneunzoomedwidth"},{"id":"tmux.FormatValues.PaneWidth","name":"PaneWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneWidth returns tmux #{pane_width} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":600,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneWidth","product":"core","slug":"tmux-formatvalues-panewidth"},{"id":"tmux.FormatValues.PaneX","name":"PaneX","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneX returns tmux #{pane_x} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":603,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneX","product":"core","slug":"tmux-formatvalues-panex"},{"id":"tmux.FormatValues.PaneY","name":"PaneY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneY returns tmux #{pane_y} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":606,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneY","product":"core","slug":"tmux-formatvalues-paney"},{"id":"tmux.FormatValues.PaneZ","name":"PaneZ","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneZ returns tmux #{pane_z} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":609,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneZ","product":"core","slug":"tmux-formatvalues-panez"},{"id":"tmux.FormatValues.PaneZoomedFlag","name":"PaneZoomedFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneZoomedFlag returns tmux #{pane_zoomed_flag} as bool from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":612,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PaneZoomedFlag","product":"core","slug":"tmux-formatvalues-panezoomedflag"},{"id":"tmux.FormatValues.PID","name":"PID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PID returns tmux #{pid} as int from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":615,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.PID","product":"core","slug":"tmux-formatvalues-pid"},{"id":"tmux.FormatValues.ScrollRegionLower","name":"ScrollRegionLower","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ScrollRegionLower returns tmux #{scroll_region_lower} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":618,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ScrollRegionLower","product":"core","slug":"tmux-formatvalues-scrollregionlower"},{"id":"tmux.FormatValues.ScrollRegionUpper","name":"ScrollRegionUpper","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ScrollRegionUpper returns tmux #{scroll_region_upper} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":621,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ScrollRegionUpper","product":"core","slug":"tmux-formatvalues-scrollregionupper"},{"id":"tmux.FormatValues.ServerSessions","name":"ServerSessions","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ServerSessions returns tmux #{server_sessions} as int from materialized universal-scoped fields (tmux 3.4 or later)."},"source":{"file":"tmux/format_generated.go","line":624,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.ServerSessions","product":"core","slug":"tmux-formatvalues-serversessions"},{"id":"tmux.FormatValues.SessionActive","name":"SessionActive","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionActive returns tmux #{session_active} as bool from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":627,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionActive","product":"core","slug":"tmux-formatvalues-sessionactive"},{"id":"tmux.FormatValues.SessionActivity","name":"SessionActivity","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"SessionActivity returns tmux #{session_activity} as time.Time from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":630,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionActivity","product":"core","slug":"tmux-formatvalues-sessionactivity"},{"id":"tmux.FormatValues.SessionActivityFlag","name":"SessionActivityFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionActivityFlag returns tmux #{session_activity_flag} as bool from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":635,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionActivityFlag","product":"core","slug":"tmux-formatvalues-sessionactivityflag"},{"id":"tmux.FormatValues.SessionAlert","name":"SessionAlert","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionAlert returns tmux #{session_alert} as string from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":640,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionAlert","product":"core","slug":"tmux-formatvalues-sessionalert"},{"id":"tmux.FormatValues.SessionAlerts","name":"SessionAlerts","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionAlerts returns tmux #{session_alerts} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":643,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionAlerts","product":"core","slug":"tmux-formatvalues-sessionalerts"},{"id":"tmux.FormatValues.SessionAttached","name":"SessionAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"SessionAttached returns tmux #{session_attached} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":646,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionAttached","product":"core","slug":"tmux-formatvalues-sessionattached"},{"id":"tmux.FormatValues.SessionAttachedList","name":"SessionAttachedList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionAttachedList returns tmux #{session_attached_list} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":649,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionAttachedList","product":"core","slug":"tmux-formatvalues-sessionattachedlist"},{"id":"tmux.FormatValues.SessionBellFlag","name":"SessionBellFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionBellFlag returns tmux #{session_bell_flag} as bool from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":654,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionBellFlag","product":"core","slug":"tmux-formatvalues-sessionbellflag"},{"id":"tmux.FormatValues.SessionCreated","name":"SessionCreated","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"SessionCreated returns tmux #{session_created} as time.Time from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":657,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionCreated","product":"core","slug":"tmux-formatvalues-sessioncreated"},{"id":"tmux.FormatValues.SessionFormat","name":"SessionFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionFormat returns tmux #{session_format} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":660,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionFormat","product":"core","slug":"tmux-formatvalues-sessionformat"},{"id":"tmux.FormatValues.SessionGroup","name":"SessionGroup","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionGroup returns tmux #{session_group} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":663,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionGroup","product":"core","slug":"tmux-formatvalues-sessiongroup"},{"id":"tmux.FormatValues.SessionGroupAttached","name":"SessionGroupAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"SessionGroupAttached returns tmux #{session_group_attached} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":666,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionGroupAttached","product":"core","slug":"tmux-formatvalues-sessiongroupattached"},{"id":"tmux.FormatValues.SessionGroupAttachedList","name":"SessionGroupAttachedList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionGroupAttachedList returns tmux #{session_group_attached_list} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":671,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionGroupAttachedList","product":"core","slug":"tmux-formatvalues-sessiongroupattachedlist"},{"id":"tmux.FormatValues.SessionGroupList","name":"SessionGroupList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionGroupList returns tmux #{session_group_list} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":676,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionGroupList","product":"core","slug":"tmux-formatvalues-sessiongrouplist"},{"id":"tmux.FormatValues.SessionGroupManyAttached","name":"SessionGroupManyAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionGroupManyAttached returns tmux #{session_group_many_attached} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":681,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionGroupManyAttached","product":"core","slug":"tmux-formatvalues-sessiongroupmanyattached"},{"id":"tmux.FormatValues.SessionGroupSize","name":"SessionGroupSize","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"SessionGroupSize returns tmux #{session_group_size} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":686,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionGroupSize","product":"core","slug":"tmux-formatvalues-sessiongroupsize"},{"id":"tmux.FormatValues.SessionGrouped","name":"SessionGrouped","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionGrouped returns tmux #{session_grouped} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":689,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionGrouped","product":"core","slug":"tmux-formatvalues-sessiongrouped"},{"id":"tmux.FormatValues.SessionID","name":"SessionID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(SessionID, bool)"}],"doc":{"summary":"SessionID returns tmux #{session_id} as SessionID from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":692,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionID","product":"core","slug":"tmux-formatvalues-sessionid"},{"id":"tmux.FormatValues.SessionLastAttached","name":"SessionLastAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"SessionLastAttached returns tmux #{session_last_attached} as time.Time from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":695,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionLastAttached","product":"core","slug":"tmux-formatvalues-sessionlastattached"},{"id":"tmux.FormatValues.SessionManyAttached","name":"SessionManyAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionManyAttached returns tmux #{session_many_attached} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":700,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionManyAttached","product":"core","slug":"tmux-formatvalues-sessionmanyattached"},{"id":"tmux.FormatValues.SessionMarked","name":"SessionMarked","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionMarked returns tmux #{session_marked} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":705,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionMarked","product":"core","slug":"tmux-formatvalues-sessionmarked"},{"id":"tmux.FormatValues.SessionName","name":"SessionName","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionName returns tmux #{session_name} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":708,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionName","product":"core","slug":"tmux-formatvalues-sessionname"},{"id":"tmux.FormatValues.SessionPath","name":"SessionPath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionPath returns tmux #{session_path} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":711,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionPath","product":"core","slug":"tmux-formatvalues-sessionpath"},{"id":"tmux.FormatValues.SessionSilenceFlag","name":"SessionSilenceFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionSilenceFlag returns tmux #{session_silence_flag} as bool from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":714,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionSilenceFlag","product":"core","slug":"tmux-formatvalues-sessionsilenceflag"},{"id":"tmux.FormatValues.SessionStack","name":"SessionStack","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionStack returns tmux #{session_stack} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":719,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionStack","product":"core","slug":"tmux-formatvalues-sessionstack"},{"id":"tmux.FormatValues.SessionWindows","name":"SessionWindows","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"SessionWindows returns tmux #{session_windows} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":722,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SessionWindows","product":"core","slug":"tmux-formatvalues-sessionwindows"},{"id":"tmux.FormatValues.SixelSupport","name":"SixelSupport","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SixelSupport returns tmux #{sixel_support} as bool from materialized universal-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":725,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SixelSupport","product":"core","slug":"tmux-formatvalues-sixelsupport"},{"id":"tmux.FormatValues.SocketPath","name":"SocketPath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SocketPath returns tmux #{socket_path} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":728,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SocketPath","product":"core","slug":"tmux-formatvalues-socketpath"},{"id":"tmux.FormatValues.StartTime","name":"StartTime","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"StartTime returns tmux #{start_time} as time.Time from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":731,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.StartTime","product":"core","slug":"tmux-formatvalues-starttime"},{"id":"tmux.FormatValues.SynchronizedOutputFlag","name":"SynchronizedOutputFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SynchronizedOutputFlag returns tmux #{synchronized_output_flag} as bool from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":734,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.SynchronizedOutputFlag","product":"core","slug":"tmux-formatvalues-synchronizedoutputflag"},{"id":"tmux.FormatValues.TreeModeFormat","name":"TreeModeFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TreeModeFormat returns tmux #{tree_mode_format} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":739,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.TreeModeFormat","product":"core","slug":"tmux-formatvalues-treemodeformat"},{"id":"tmux.FormatValues.UID","name":"UID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"UID returns tmux #{uid} as int from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":742,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.UID","product":"core","slug":"tmux-formatvalues-uid"},{"id":"tmux.FormatValues.User","name":"User","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"User returns tmux #{user} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":745,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.User","product":"core","slug":"tmux-formatvalues-user"},{"id":"tmux.FormatValues.Version","name":"Version","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(Version, bool)"}],"doc":{"summary":"Version returns tmux #{version} as Version from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":748,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.Version","product":"core","slug":"tmux-formatvalues-version"},{"id":"tmux.FormatValues.WindowActive","name":"WindowActive","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowActive returns tmux #{window_active} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":751,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowActive","product":"core","slug":"tmux-formatvalues-windowactive"},{"id":"tmux.FormatValues.WindowActiveClients","name":"WindowActiveClients","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowActiveClients returns tmux #{window_active_clients} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":754,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowActiveClients","product":"core","slug":"tmux-formatvalues-windowactiveclients"},{"id":"tmux.FormatValues.WindowActiveClientsList","name":"WindowActiveClientsList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowActiveClientsList returns tmux #{window_active_clients_list} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":759,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowActiveClientsList","product":"core","slug":"tmux-formatvalues-windowactiveclientslist"},{"id":"tmux.FormatValues.WindowActiveSessions","name":"WindowActiveSessions","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowActiveSessions returns tmux #{window_active_sessions} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":764,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowActiveSessions","product":"core","slug":"tmux-formatvalues-windowactivesessions"},{"id":"tmux.FormatValues.WindowActiveSessionsList","name":"WindowActiveSessionsList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowActiveSessionsList returns tmux #{window_active_sessions_list} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":769,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowActiveSessionsList","product":"core","slug":"tmux-formatvalues-windowactivesessionslist"},{"id":"tmux.FormatValues.WindowActivity","name":"WindowActivity","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"WindowActivity returns tmux #{window_activity} as time.Time from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":774,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowActivity","product":"core","slug":"tmux-formatvalues-windowactivity"},{"id":"tmux.FormatValues.WindowActivityFlag","name":"WindowActivityFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowActivityFlag returns tmux #{window_activity_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":777,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowActivityFlag","product":"core","slug":"tmux-formatvalues-windowactivityflag"},{"id":"tmux.FormatValues.WindowBellFlag","name":"WindowBellFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowBellFlag returns tmux #{window_bell_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":782,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowBellFlag","product":"core","slug":"tmux-formatvalues-windowbellflag"},{"id":"tmux.FormatValues.WindowBigger","name":"WindowBigger","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowBigger returns tmux #{window_bigger} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":785,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowBigger","product":"core","slug":"tmux-formatvalues-windowbigger"},{"id":"tmux.FormatValues.WindowCellHeight","name":"WindowCellHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowCellHeight returns tmux #{window_cell_height} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":788,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowCellHeight","product":"core","slug":"tmux-formatvalues-windowcellheight"},{"id":"tmux.FormatValues.WindowCellWidth","name":"WindowCellWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowCellWidth returns tmux #{window_cell_width} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":791,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowCellWidth","product":"core","slug":"tmux-formatvalues-windowcellwidth"},{"id":"tmux.FormatValues.WindowEndFlag","name":"WindowEndFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowEndFlag returns tmux #{window_end_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":794,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowEndFlag","product":"core","slug":"tmux-formatvalues-windowendflag"},{"id":"tmux.FormatValues.WindowFlags","name":"WindowFlags","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowFlags returns tmux #{window_flags} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":797,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowFlags","product":"core","slug":"tmux-formatvalues-windowflags"},{"id":"tmux.FormatValues.WindowFormat","name":"WindowFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowFormat returns tmux #{window_format} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":800,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowFormat","product":"core","slug":"tmux-formatvalues-windowformat"},{"id":"tmux.FormatValues.WindowHeight","name":"WindowHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowHeight returns tmux #{window_height} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":803,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowHeight","product":"core","slug":"tmux-formatvalues-windowheight"},{"id":"tmux.FormatValues.WindowID","name":"WindowID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(WindowID, bool)"}],"doc":{"summary":"WindowID returns tmux #{window_id} as WindowID from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":806,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowID","product":"core","slug":"tmux-formatvalues-windowid"},{"id":"tmux.FormatValues.WindowIndex","name":"WindowIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowIndex returns tmux #{window_index} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":809,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowIndex","product":"core","slug":"tmux-formatvalues-windowindex"},{"id":"tmux.FormatValues.WindowLastFlag","name":"WindowLastFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowLastFlag returns tmux #{window_last_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":812,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowLastFlag","product":"core","slug":"tmux-formatvalues-windowlastflag"},{"id":"tmux.FormatValues.WindowLayout","name":"WindowLayout","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowLayout returns tmux #{window_layout} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":815,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowLayout","product":"core","slug":"tmux-formatvalues-windowlayout"},{"id":"tmux.FormatValues.WindowLinked","name":"WindowLinked","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowLinked returns tmux #{window_linked} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":818,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowLinked","product":"core","slug":"tmux-formatvalues-windowlinked"},{"id":"tmux.FormatValues.WindowLinkedSessions","name":"WindowLinkedSessions","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowLinkedSessions returns tmux #{window_linked_sessions} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":821,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowLinkedSessions","product":"core","slug":"tmux-formatvalues-windowlinkedsessions"},{"id":"tmux.FormatValues.WindowLinkedSessionsList","name":"WindowLinkedSessionsList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowLinkedSessionsList returns tmux #{window_linked_sessions_list} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":826,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowLinkedSessionsList","product":"core","slug":"tmux-formatvalues-windowlinkedsessionslist"},{"id":"tmux.FormatValues.WindowManualHeight","name":"WindowManualHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowManualHeight returns tmux #{window_manual_height} as int from materialized window-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":831,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowManualHeight","product":"core","slug":"tmux-formatvalues-windowmanualheight"},{"id":"tmux.FormatValues.WindowManualWidth","name":"WindowManualWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowManualWidth returns tmux #{window_manual_width} as int from materialized window-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":836,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowManualWidth","product":"core","slug":"tmux-formatvalues-windowmanualwidth"},{"id":"tmux.FormatValues.WindowMarkedFlag","name":"WindowMarkedFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowMarkedFlag returns tmux #{window_marked_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":839,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowMarkedFlag","product":"core","slug":"tmux-formatvalues-windowmarkedflag"},{"id":"tmux.FormatValues.WindowName","name":"WindowName","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowName returns tmux #{window_name} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":842,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowName","product":"core","slug":"tmux-formatvalues-windowname"},{"id":"tmux.FormatValues.WindowOffsetX","name":"WindowOffsetX","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowOffsetX returns tmux #{window_offset_x} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":845,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowOffsetX","product":"core","slug":"tmux-formatvalues-windowoffsetx"},{"id":"tmux.FormatValues.WindowOffsetY","name":"WindowOffsetY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowOffsetY returns tmux #{window_offset_y} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":848,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowOffsetY","product":"core","slug":"tmux-formatvalues-windowoffsety"},{"id":"tmux.FormatValues.WindowPanes","name":"WindowPanes","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowPanes returns tmux #{window_panes} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":851,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowPanes","product":"core","slug":"tmux-formatvalues-windowpanes"},{"id":"tmux.FormatValues.WindowRawFlags","name":"WindowRawFlags","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowRawFlags returns tmux #{window_raw_flags} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":854,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowRawFlags","product":"core","slug":"tmux-formatvalues-windowrawflags"},{"id":"tmux.FormatValues.WindowSilenceFlag","name":"WindowSilenceFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowSilenceFlag returns tmux #{window_silence_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":857,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowSilenceFlag","product":"core","slug":"tmux-formatvalues-windowsilenceflag"},{"id":"tmux.FormatValues.WindowStackIndex","name":"WindowStackIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowStackIndex returns tmux #{window_stack_index} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":862,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowStackIndex","product":"core","slug":"tmux-formatvalues-windowstackindex"},{"id":"tmux.FormatValues.WindowStartFlag","name":"WindowStartFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowStartFlag returns tmux #{window_start_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":865,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowStartFlag","product":"core","slug":"tmux-formatvalues-windowstartflag"},{"id":"tmux.FormatValues.WindowVisibleLayout","name":"WindowVisibleLayout","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowVisibleLayout returns tmux #{window_visible_layout} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":868,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowVisibleLayout","product":"core","slug":"tmux-formatvalues-windowvisiblelayout"},{"id":"tmux.FormatValues.WindowWidth","name":"WindowWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowWidth returns tmux #{window_width} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":873,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowWidth","product":"core","slug":"tmux-formatvalues-windowwidth"},{"id":"tmux.FormatValues.WindowZoomedFlag","name":"WindowZoomedFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowZoomedFlag returns tmux #{window_zoomed_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":876,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WindowZoomedFlag","product":"core","slug":"tmux-formatvalues-windowzoomedflag"},{"id":"tmux.FormatValues.WrapFlag","name":"WrapFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WrapFlag returns tmux #{wrap_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":879,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.WrapFlag","product":"core","slug":"tmux-formatvalues-wrapflag"},{"id":"tmux.Session.ActiveWindowIndex","name":"ActiveWindowIndex","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ActiveWindowIndex returns tmux #{active_window_index} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":882,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ActiveWindowIndex","product":"core","slug":"tmux-session-activewindowindex"},{"id":"tmux.Session.LastWindowIndex","name":"LastWindowIndex","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"LastWindowIndex returns tmux #{last_window_index} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":885,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.LastWindowIndex","product":"core","slug":"tmux-session-lastwindowindex"},{"id":"tmux.Session.Active","name":"Active","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Active returns tmux #{session_active} as bool from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":888,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Active","product":"core","slug":"tmux-session-active"},{"id":"tmux.Session.Activity","name":"Activity","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Activity returns tmux #{session_activity} as time.Time from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":891,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Activity","product":"core","slug":"tmux-session-activity"},{"id":"tmux.Session.ActivityFlag","name":"ActivityFlag","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ActivityFlag returns tmux #{session_activity_flag} as bool from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":894,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ActivityFlag","product":"core","slug":"tmux-session-activityflag"},{"id":"tmux.Session.Alert","name":"Alert","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Alert returns tmux #{session_alert} as string from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":897,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Alert","product":"core","slug":"tmux-session-alert"},{"id":"tmux.Session.Alerts","name":"Alerts","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Alerts returns tmux #{session_alerts} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":900,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Alerts","product":"core","slug":"tmux-session-alerts"},{"id":"tmux.Session.Attached","name":"Attached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Attached returns tmux #{session_attached} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":903,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Attached","product":"core","slug":"tmux-session-attached"},{"id":"tmux.Session.AttachedList","name":"AttachedList","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"AttachedList returns tmux #{session_attached_list} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":906,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.AttachedList","product":"core","slug":"tmux-session-attachedlist"},{"id":"tmux.Session.BellFlag","name":"BellFlag","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"BellFlag returns tmux #{session_bell_flag} as bool from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":909,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.BellFlag","product":"core","slug":"tmux-session-bellflag"},{"id":"tmux.Session.Created","name":"Created","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Created returns tmux #{session_created} as time.Time from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":912,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Created","product":"core","slug":"tmux-session-created"},{"id":"tmux.Session.Format","name":"Format","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Format returns tmux #{session_format} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":915,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Format","product":"core","slug":"tmux-session-format"},{"id":"tmux.Session.Group","name":"Group","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Group returns tmux #{session_group} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":918,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Group","product":"core","slug":"tmux-session-group"},{"id":"tmux.Session.GroupAttached","name":"GroupAttached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"GroupAttached returns tmux #{session_group_attached} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":921,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.GroupAttached","product":"core","slug":"tmux-session-groupattached"},{"id":"tmux.Session.GroupAttachedList","name":"GroupAttachedList","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"GroupAttachedList returns tmux #{session_group_attached_list} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":924,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.GroupAttachedList","product":"core","slug":"tmux-session-groupattachedlist"},{"id":"tmux.Session.GroupList","name":"GroupList","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"GroupList returns tmux #{session_group_list} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":929,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.GroupList","product":"core","slug":"tmux-session-grouplist"},{"id":"tmux.Session.GroupManyAttached","name":"GroupManyAttached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"GroupManyAttached returns tmux #{session_group_many_attached} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":932,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.GroupManyAttached","product":"core","slug":"tmux-session-groupmanyattached"},{"id":"tmux.Session.GroupSize","name":"GroupSize","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"GroupSize returns tmux #{session_group_size} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":937,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.GroupSize","product":"core","slug":"tmux-session-groupsize"},{"id":"tmux.Session.Grouped","name":"Grouped","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Grouped returns tmux #{session_grouped} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":940,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Grouped","product":"core","slug":"tmux-session-grouped"},{"id":"tmux.Session.LastAttached","name":"LastAttached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"LastAttached returns tmux #{session_last_attached} as time.Time from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":943,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.LastAttached","product":"core","slug":"tmux-session-lastattached"},{"id":"tmux.Session.ManyAttached","name":"ManyAttached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ManyAttached returns tmux #{session_many_attached} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":946,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ManyAttached","product":"core","slug":"tmux-session-manyattached"},{"id":"tmux.Session.Marked","name":"Marked","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Marked returns tmux #{session_marked} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":949,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Marked","product":"core","slug":"tmux-session-marked"},{"id":"tmux.Session.Name","name":"Name","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Name returns tmux #{session_name} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":952,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Name","product":"core","slug":"tmux-session-name"},{"id":"tmux.Session.Path","name":"Path","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Path returns tmux #{session_path} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":955,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Path","product":"core","slug":"tmux-session-path"},{"id":"tmux.Session.SilenceFlag","name":"SilenceFlag","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SilenceFlag returns tmux #{session_silence_flag} as bool from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":958,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SilenceFlag","product":"core","slug":"tmux-session-silenceflag"},{"id":"tmux.Session.Stack","name":"Stack","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Stack returns tmux #{session_stack} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":961,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Stack","product":"core","slug":"tmux-session-stack"},{"id":"tmux.Session.WindowCount","name":"WindowCount","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowCount returns tmux #{session_windows} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":964,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.WindowCount","product":"core","slug":"tmux-session-windowcount"},{"id":"tmux.Window.Active","name":"Active","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Active returns tmux #{window_active} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":967,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Active","product":"core","slug":"tmux-window-active"},{"id":"tmux.Window.ActiveClients","name":"ActiveClients","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ActiveClients returns tmux #{window_active_clients} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":970,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ActiveClients","product":"core","slug":"tmux-window-activeclients"},{"id":"tmux.Window.ActiveClientsList","name":"ActiveClientsList","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ActiveClientsList returns tmux #{window_active_clients_list} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":973,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ActiveClientsList","product":"core","slug":"tmux-window-activeclientslist"},{"id":"tmux.Window.ActiveSessions","name":"ActiveSessions","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ActiveSessions returns tmux #{window_active_sessions} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":978,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ActiveSessions","product":"core","slug":"tmux-window-activesessions"},{"id":"tmux.Window.ActiveSessionsList","name":"ActiveSessionsList","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ActiveSessionsList returns tmux #{window_active_sessions_list} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":981,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ActiveSessionsList","product":"core","slug":"tmux-window-activesessionslist"},{"id":"tmux.Window.Activity","name":"Activity","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Activity returns tmux #{window_activity} as time.Time from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":986,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Activity","product":"core","slug":"tmux-window-activity"},{"id":"tmux.Window.ActivityFlag","name":"ActivityFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ActivityFlag returns tmux #{window_activity_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":989,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ActivityFlag","product":"core","slug":"tmux-window-activityflag"},{"id":"tmux.Window.BellFlag","name":"BellFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"BellFlag returns tmux #{window_bell_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":992,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.BellFlag","product":"core","slug":"tmux-window-bellflag"},{"id":"tmux.Window.Bigger","name":"Bigger","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Bigger returns tmux #{window_bigger} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":995,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Bigger","product":"core","slug":"tmux-window-bigger"},{"id":"tmux.Window.CellHeight","name":"CellHeight","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CellHeight returns tmux #{window_cell_height} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":998,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.CellHeight","product":"core","slug":"tmux-window-cellheight"},{"id":"tmux.Window.CellWidth","name":"CellWidth","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CellWidth returns tmux #{window_cell_width} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1001,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.CellWidth","product":"core","slug":"tmux-window-cellwidth"},{"id":"tmux.Window.EndFlag","name":"EndFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"EndFlag returns tmux #{window_end_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1004,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.EndFlag","product":"core","slug":"tmux-window-endflag"},{"id":"tmux.Window.Flags","name":"Flags","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Flags returns tmux #{window_flags} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1007,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Flags","product":"core","slug":"tmux-window-flags"},{"id":"tmux.Window.Format","name":"Format","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Format returns tmux #{window_format} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1010,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Format","product":"core","slug":"tmux-window-format"},{"id":"tmux.Window.Height","name":"Height","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Height returns tmux #{window_height} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1013,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Height","product":"core","slug":"tmux-window-height"},{"id":"tmux.Window.LastFlag","name":"LastFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"LastFlag returns tmux #{window_last_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1016,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.LastFlag","product":"core","slug":"tmux-window-lastflag"},{"id":"tmux.Window.Layout","name":"Layout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Layout returns tmux #{window_layout} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1019,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Layout","product":"core","slug":"tmux-window-layout"},{"id":"tmux.Window.Linked","name":"Linked","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Linked returns tmux #{window_linked} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1022,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Linked","product":"core","slug":"tmux-window-linked"},{"id":"tmux.Window.LinkedSessionCount","name":"LinkedSessionCount","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"LinkedSessionCount returns tmux #{window_linked_sessions} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1025,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.LinkedSessionCount","product":"core","slug":"tmux-window-linkedsessioncount"},{"id":"tmux.Window.LinkedSessionsList","name":"LinkedSessionsList","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"LinkedSessionsList returns tmux #{window_linked_sessions_list} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1028,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.LinkedSessionsList","product":"core","slug":"tmux-window-linkedsessionslist"},{"id":"tmux.Window.ManualHeight","name":"ManualHeight","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ManualHeight returns tmux #{window_manual_height} as int from this Window's materialized window-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1033,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ManualHeight","product":"core","slug":"tmux-window-manualheight"},{"id":"tmux.Window.ManualWidth","name":"ManualWidth","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ManualWidth returns tmux #{window_manual_width} as int from this Window's materialized window-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1036,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ManualWidth","product":"core","slug":"tmux-window-manualwidth"},{"id":"tmux.Window.MarkedFlag","name":"MarkedFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MarkedFlag returns tmux #{window_marked_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1039,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.MarkedFlag","product":"core","slug":"tmux-window-markedflag"},{"id":"tmux.Window.Name","name":"Name","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Name returns tmux #{window_name} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1042,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Name","product":"core","slug":"tmux-window-name"},{"id":"tmux.Window.OffsetX","name":"OffsetX","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"OffsetX returns tmux #{window_offset_x} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1045,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.OffsetX","product":"core","slug":"tmux-window-offsetx"},{"id":"tmux.Window.OffsetY","name":"OffsetY","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"OffsetY returns tmux #{window_offset_y} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1048,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.OffsetY","product":"core","slug":"tmux-window-offsety"},{"id":"tmux.Window.PaneCount","name":"PaneCount","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneCount returns tmux #{window_panes} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1051,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.PaneCount","product":"core","slug":"tmux-window-panecount"},{"id":"tmux.Window.RawFlags","name":"RawFlags","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"RawFlags returns tmux #{window_raw_flags} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1054,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.RawFlags","product":"core","slug":"tmux-window-rawflags"},{"id":"tmux.Window.SilenceFlag","name":"SilenceFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SilenceFlag returns tmux #{window_silence_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1057,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SilenceFlag","product":"core","slug":"tmux-window-silenceflag"},{"id":"tmux.Window.StackIndex","name":"StackIndex","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"StackIndex returns tmux #{window_stack_index} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1060,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.StackIndex","product":"core","slug":"tmux-window-stackindex"},{"id":"tmux.Window.StartFlag","name":"StartFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"StartFlag returns tmux #{window_start_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1063,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.StartFlag","product":"core","slug":"tmux-window-startflag"},{"id":"tmux.Window.VisibleLayout","name":"VisibleLayout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"VisibleLayout returns tmux #{window_visible_layout} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1066,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.VisibleLayout","product":"core","slug":"tmux-window-visiblelayout"},{"id":"tmux.Window.Width","name":"Width","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Width returns tmux #{window_width} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1069,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Width","product":"core","slug":"tmux-window-width"},{"id":"tmux.Window.ZoomedFlag","name":"ZoomedFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ZoomedFlag returns tmux #{window_zoomed_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1072,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ZoomedFlag","product":"core","slug":"tmux-window-zoomedflag"},{"id":"tmux.Pane.AlternateOn","name":"AlternateOn","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AlternateOn returns tmux #{alternate_on} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1075,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AlternateOn","product":"core","slug":"tmux-pane-alternateon"},{"id":"tmux.Pane.AlternateSavedX","name":"AlternateSavedX","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"AlternateSavedX returns tmux #{alternate_saved_x} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1078,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AlternateSavedX","product":"core","slug":"tmux-pane-alternatesavedx"},{"id":"tmux.Pane.AlternateSavedY","name":"AlternateSavedY","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"AlternateSavedY returns tmux #{alternate_saved_y} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1081,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AlternateSavedY","product":"core","slug":"tmux-pane-alternatesavedy"},{"id":"tmux.Pane.BracketPasteFlag","name":"BracketPasteFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"BracketPasteFlag returns tmux #{bracket_paste_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1084,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.BracketPasteFlag","product":"core","slug":"tmux-pane-bracketpasteflag"},{"id":"tmux.Pane.CursorBlinking","name":"CursorBlinking","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorBlinking returns tmux #{cursor_blinking} as bool from this Pane's materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":1087,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CursorBlinking","product":"core","slug":"tmux-pane-cursorblinking"},{"id":"tmux.Pane.CursorCharacter","name":"CursorCharacter","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorCharacter returns tmux #{cursor_character} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1090,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CursorCharacter","product":"core","slug":"tmux-pane-cursorcharacter"},{"id":"tmux.Pane.CursorColour","name":"CursorColour","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorColour returns tmux #{cursor_colour} as string from this Pane's materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":1093,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CursorColour","product":"core","slug":"tmux-pane-cursorcolour"},{"id":"tmux.Pane.CursorFlag","name":"CursorFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorFlag returns tmux #{cursor_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1096,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CursorFlag","product":"core","slug":"tmux-pane-cursorflag"},{"id":"tmux.Pane.CursorShape","name":"CursorShape","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorShape returns tmux #{cursor_shape} as string from this Pane's materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":1099,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CursorShape","product":"core","slug":"tmux-pane-cursorshape"},{"id":"tmux.Pane.CursorVeryVisible","name":"CursorVeryVisible","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorVeryVisible returns tmux #{cursor_very_visible} as bool from this Pane's materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":1102,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CursorVeryVisible","product":"core","slug":"tmux-pane-cursorveryvisible"},{"id":"tmux.Pane.CursorX","name":"CursorX","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CursorX returns tmux #{cursor_x} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1105,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CursorX","product":"core","slug":"tmux-pane-cursorx"},{"id":"tmux.Pane.CursorY","name":"CursorY","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CursorY returns tmux #{cursor_y} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CursorY","product":"core","slug":"tmux-pane-cursory"},{"id":"tmux.Pane.HistoryAdded","name":"HistoryAdded","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryAdded returns tmux #{history_added} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.HistoryAdded","product":"core","slug":"tmux-pane-historyadded"},{"id":"tmux.Pane.HistoryAllBytes","name":"HistoryAllBytes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"HistoryAllBytes returns tmux #{history_all_bytes} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1114,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.HistoryAllBytes","product":"core","slug":"tmux-pane-historyallbytes"},{"id":"tmux.Pane.HistoryBytes","name":"HistoryBytes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryBytes returns tmux #{history_bytes} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1117,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.HistoryBytes","product":"core","slug":"tmux-pane-historybytes"},{"id":"tmux.Pane.HistoryCollected","name":"HistoryCollected","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryCollected returns tmux #{history_collected} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1120,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.HistoryCollected","product":"core","slug":"tmux-pane-historycollected"},{"id":"tmux.Pane.HistoryGeneration","name":"HistoryGeneration","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryGeneration returns tmux #{history_generation} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1123,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.HistoryGeneration","product":"core","slug":"tmux-pane-historygeneration"},{"id":"tmux.Pane.HistoryLimit","name":"HistoryLimit","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryLimit returns tmux #{history_limit} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1126,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.HistoryLimit","product":"core","slug":"tmux-pane-historylimit"},{"id":"tmux.Pane.HistorySize","name":"HistorySize","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistorySize returns tmux #{history_size} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1129,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.HistorySize","product":"core","slug":"tmux-pane-historysize"},{"id":"tmux.Pane.InsertFlag","name":"InsertFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"InsertFlag returns tmux #{insert_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1132,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.InsertFlag","product":"core","slug":"tmux-pane-insertflag"},{"id":"tmux.Pane.KeypadCursorFlag","name":"KeypadCursorFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"KeypadCursorFlag returns tmux #{keypad_cursor_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1135,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.KeypadCursorFlag","product":"core","slug":"tmux-pane-keypadcursorflag"},{"id":"tmux.Pane.KeypadFlag","name":"KeypadFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"KeypadFlag returns tmux #{keypad_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1138,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.KeypadFlag","product":"core","slug":"tmux-pane-keypadflag"},{"id":"tmux.Pane.MouseAllFlag","name":"MouseAllFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseAllFlag returns tmux #{mouse_all_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1141,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.MouseAllFlag","product":"core","slug":"tmux-pane-mouseallflag"},{"id":"tmux.Pane.MouseAnyFlag","name":"MouseAnyFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseAnyFlag returns tmux #{mouse_any_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1144,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.MouseAnyFlag","product":"core","slug":"tmux-pane-mouseanyflag"},{"id":"tmux.Pane.MouseButtonFlag","name":"MouseButtonFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseButtonFlag returns tmux #{mouse_button_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1147,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.MouseButtonFlag","product":"core","slug":"tmux-pane-mousebuttonflag"},{"id":"tmux.Pane.MouseSGRFlag","name":"MouseSGRFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseSGRFlag returns tmux #{mouse_sgr_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1150,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.MouseSGRFlag","product":"core","slug":"tmux-pane-mousesgrflag"},{"id":"tmux.Pane.MouseStandardFlag","name":"MouseStandardFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseStandardFlag returns tmux #{mouse_standard_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1153,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.MouseStandardFlag","product":"core","slug":"tmux-pane-mousestandardflag"},{"id":"tmux.Pane.MouseUTF8Flag","name":"MouseUTF8Flag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseUTF8Flag returns tmux #{mouse_utf8_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1156,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.MouseUTF8Flag","product":"core","slug":"tmux-pane-mouseutf8flag"},{"id":"tmux.Pane.OriginFlag","name":"OriginFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"OriginFlag returns tmux #{origin_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1159,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.OriginFlag","product":"core","slug":"tmux-pane-originflag"},{"id":"tmux.Pane.Active","name":"Active","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Active returns tmux #{pane_active} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1162,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Active","product":"core","slug":"tmux-pane-active"},{"id":"tmux.Pane.AtBottom","name":"AtBottom","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AtBottom returns tmux #{pane_at_bottom} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1165,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AtBottom","product":"core","slug":"tmux-pane-atbottom"},{"id":"tmux.Pane.AtLeft","name":"AtLeft","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AtLeft returns tmux #{pane_at_left} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1168,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AtLeft","product":"core","slug":"tmux-pane-atleft"},{"id":"tmux.Pane.AtRight","name":"AtRight","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AtRight returns tmux #{pane_at_right} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1171,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AtRight","product":"core","slug":"tmux-pane-atright"},{"id":"tmux.Pane.AtTop","name":"AtTop","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AtTop returns tmux #{pane_at_top} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1174,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AtTop","product":"core","slug":"tmux-pane-attop"},{"id":"tmux.Pane.BG","name":"BG","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"BG returns tmux #{pane_bg} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1177,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.BG","product":"core","slug":"tmux-pane-bg"},{"id":"tmux.Pane.Bottom","name":"Bottom","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Bottom returns tmux #{pane_bottom} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1180,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Bottom","product":"core","slug":"tmux-pane-bottom"},{"id":"tmux.Pane.CommandRunning","name":"CommandRunning","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CommandRunning returns tmux #{pane_command_running} as bool from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1183,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CommandRunning","product":"core","slug":"tmux-pane-commandrunning"},{"id":"tmux.Pane.CurrentCommand","name":"CurrentCommand","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CurrentCommand returns tmux #{pane_current_command} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1186,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CurrentCommand","product":"core","slug":"tmux-pane-currentcommand"},{"id":"tmux.Pane.CurrentPath","name":"CurrentPath","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CurrentPath returns tmux #{pane_current_path} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1189,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CurrentPath","product":"core","slug":"tmux-pane-currentpath"},{"id":"tmux.Pane.Dead","name":"Dead","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Dead returns tmux #{pane_dead} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1192,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Dead","product":"core","slug":"tmux-pane-dead"},{"id":"tmux.Pane.DeadSignal","name":"DeadSignal","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"DeadSignal returns tmux #{pane_dead_signal} as string from this Pane's materialized pane-scoped fields (tmux 3.3 or later)."},"source":{"file":"tmux/format_generated.go","line":1195,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.DeadSignal","product":"core","slug":"tmux-pane-deadsignal"},{"id":"tmux.Pane.DeadStatus","name":"DeadStatus","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"DeadStatus returns tmux #{pane_dead_status} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1198,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.DeadStatus","product":"core","slug":"tmux-pane-deadstatus"},{"id":"tmux.Pane.DeadTime","name":"DeadTime","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"DeadTime returns tmux #{pane_dead_time} as time.Time from this Pane's materialized pane-scoped fields (tmux 3.3 or later)."},"source":{"file":"tmux/format_generated.go","line":1201,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.DeadTime","product":"core","slug":"tmux-pane-deadtime"},{"id":"tmux.Pane.FG","name":"FG","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"FG returns tmux #{pane_fg} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1204,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.FG","product":"core","slug":"tmux-pane-fg"},{"id":"tmux.Pane.Flags","name":"Flags","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Flags returns tmux #{pane_flags} as string from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1207,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Flags","product":"core","slug":"tmux-pane-flags"},{"id":"tmux.Pane.FloatingFlag","name":"FloatingFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"FloatingFlag returns tmux #{pane_floating_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1210,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.FloatingFlag","product":"core","slug":"tmux-pane-floatingflag"},{"id":"tmux.Pane.Format","name":"Format","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Format returns tmux #{pane_format} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1213,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Format","product":"core","slug":"tmux-pane-format"},{"id":"tmux.Pane.Height","name":"Height","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Height returns tmux #{pane_height} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1216,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Height","product":"core","slug":"tmux-pane-height"},{"id":"tmux.Pane.InMode","name":"InMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"InMode returns tmux #{pane_in_mode} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1219,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.InMode","product":"core","slug":"tmux-pane-inmode"},{"id":"tmux.Pane.InputOff","name":"InputOff","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"InputOff returns tmux #{pane_input_off} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1222,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.InputOff","product":"core","slug":"tmux-pane-inputoff"},{"id":"tmux.Pane.KeyMode","name":"KeyMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"KeyMode returns tmux #{pane_key_mode} as string from this Pane's materialized pane-scoped fields (tmux 3.5 or later)."},"source":{"file":"tmux/format_generated.go","line":1225,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.KeyMode","product":"core","slug":"tmux-pane-keymode"},{"id":"tmux.Pane.Last","name":"Last","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Last returns tmux #{pane_last} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1228,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Last","product":"core","slug":"tmux-pane-last"},{"id":"tmux.Pane.Left","name":"Left","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Left returns tmux #{pane_left} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1231,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Left","product":"core","slug":"tmux-pane-left"},{"id":"tmux.Pane.Marked","name":"Marked","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Marked returns tmux #{pane_marked} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1234,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Marked","product":"core","slug":"tmux-pane-marked"},{"id":"tmux.Pane.MarkedSet","name":"MarkedSet","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MarkedSet returns tmux #{pane_marked_set} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1237,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.MarkedSet","product":"core","slug":"tmux-pane-markedset"},{"id":"tmux.Pane.ModalFlag","name":"ModalFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ModalFlag returns tmux #{pane_modal_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1240,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ModalFlag","product":"core","slug":"tmux-pane-modalflag"},{"id":"tmux.Pane.Mode","name":"Mode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Mode returns tmux #{pane_mode} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1243,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Mode","product":"core","slug":"tmux-pane-mode"},{"id":"tmux.Pane.OutputGeneration","name":"OutputGeneration","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"OutputGeneration returns tmux #{pane_output_generation} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1246,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.OutputGeneration","product":"core","slug":"tmux-pane-outputgeneration"},{"id":"tmux.Pane.Path","name":"Path","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Path returns tmux #{pane_path} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1249,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Path","product":"core","slug":"tmux-pane-path"},{"id":"tmux.Pane.PBProgress","name":"PBProgress","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PBProgress returns tmux #{pane_pb_progress} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1252,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.PBProgress","product":"core","slug":"tmux-pane-pbprogress"},{"id":"tmux.Pane.PBState","name":"PBState","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PBState returns tmux #{pane_pb_state} as string from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1255,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.PBState","product":"core","slug":"tmux-pane-pbstate"},{"id":"tmux.Pane.ProcessPID","name":"ProcessPID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ProcessPID returns tmux #{pane_pid} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1258,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ProcessPID","product":"core","slug":"tmux-pane-processpid"},{"id":"tmux.Pane.Piping","name":"Piping","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Piping returns tmux #{pane_pipe} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1261,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Piping","product":"core","slug":"tmux-pane-piping"},{"id":"tmux.Pane.PipePID","name":"PipePID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PipePID returns tmux #{pane_pipe_pid} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1264,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.PipePID","product":"core","slug":"tmux-pane-pipepid"},{"id":"tmux.Pane.PrivateModes","name":"PrivateModes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PrivateModes returns tmux #{pane_private_modes} as string from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1267,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.PrivateModes","product":"core","slug":"tmux-pane-privatemodes"},{"id":"tmux.Pane.Right","name":"Right","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Right returns tmux #{pane_right} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1270,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Right","product":"core","slug":"tmux-pane-right"},{"id":"tmux.Pane.SearchString","name":"SearchString","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SearchString returns tmux #{pane_search_string} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1273,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SearchString","product":"core","slug":"tmux-pane-searchstring"},{"id":"tmux.Pane.StartCommand","name":"StartCommand","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"StartCommand returns tmux #{pane_start_command} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1276,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.StartCommand","product":"core","slug":"tmux-pane-startcommand"},{"id":"tmux.Pane.StartCommandList","name":"StartCommandList","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"StartCommandList returns tmux #{pane_start_command_list} as string from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1279,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.StartCommandList","product":"core","slug":"tmux-pane-startcommandlist"},{"id":"tmux.Pane.StartPath","name":"StartPath","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"StartPath returns tmux #{pane_start_path} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1284,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.StartPath","product":"core","slug":"tmux-pane-startpath"},{"id":"tmux.Pane.Synchronized","name":"Synchronized","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Synchronized returns tmux #{pane_synchronized} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1287,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Synchronized","product":"core","slug":"tmux-pane-synchronized"},{"id":"tmux.Pane.Tabs","name":"Tabs","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Tabs returns tmux #{pane_tabs} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1290,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Tabs","product":"core","slug":"tmux-pane-tabs"},{"id":"tmux.Pane.Title","name":"Title","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Title returns tmux #{pane_title} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1293,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Title","product":"core","slug":"tmux-pane-title"},{"id":"tmux.Pane.Top","name":"Top","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Top returns tmux #{pane_top} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1296,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Top","product":"core","slug":"tmux-pane-top"},{"id":"tmux.Pane.TTY","name":"TTY","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TTY returns tmux #{pane_tty} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1299,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.TTY","product":"core","slug":"tmux-pane-tty"},{"id":"tmux.Pane.UnseenChanges","name":"UnseenChanges","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"UnseenChanges returns tmux #{pane_unseen_changes} as bool from this Pane's materialized pane-scoped fields (tmux 3.4 or later)."},"source":{"file":"tmux/format_generated.go","line":1302,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.UnseenChanges","product":"core","slug":"tmux-pane-unseenchanges"},{"id":"tmux.Pane.UnzoomedHeight","name":"UnzoomedHeight","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"UnzoomedHeight returns tmux #{pane_unzoomed_height} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1305,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.UnzoomedHeight","product":"core","slug":"tmux-pane-unzoomedheight"},{"id":"tmux.Pane.UnzoomedWidth","name":"UnzoomedWidth","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"UnzoomedWidth returns tmux #{pane_unzoomed_width} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1308,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.UnzoomedWidth","product":"core","slug":"tmux-pane-unzoomedwidth"},{"id":"tmux.Pane.Width","name":"Width","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Width returns tmux #{pane_width} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1311,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Width","product":"core","slug":"tmux-pane-width"},{"id":"tmux.Pane.X","name":"X","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"X returns tmux #{pane_x} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1314,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.X","product":"core","slug":"tmux-pane-x"},{"id":"tmux.Pane.Y","name":"Y","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Y returns tmux #{pane_y} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1317,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Y","product":"core","slug":"tmux-pane-y"},{"id":"tmux.Pane.Z","name":"Z","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Z returns tmux #{pane_z} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1320,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Z","product":"core","slug":"tmux-pane-z"},{"id":"tmux.Pane.ZoomedFlag","name":"ZoomedFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ZoomedFlag returns tmux #{pane_zoomed_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1323,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ZoomedFlag","product":"core","slug":"tmux-pane-zoomedflag"},{"id":"tmux.Pane.ScrollRegionLower","name":"ScrollRegionLower","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ScrollRegionLower returns tmux #{scroll_region_lower} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1326,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ScrollRegionLower","product":"core","slug":"tmux-pane-scrollregionlower"},{"id":"tmux.Pane.ScrollRegionUpper","name":"ScrollRegionUpper","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ScrollRegionUpper returns tmux #{scroll_region_upper} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1329,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ScrollRegionUpper","product":"core","slug":"tmux-pane-scrollregionupper"},{"id":"tmux.Pane.SynchronizedOutputFlag","name":"SynchronizedOutputFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SynchronizedOutputFlag returns tmux #{synchronized_output_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1332,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SynchronizedOutputFlag","product":"core","slug":"tmux-pane-synchronizedoutputflag"},{"id":"tmux.Pane.WrapFlag","name":"WrapFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WrapFlag returns tmux #{wrap_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1337,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.WrapFlag","product":"core","slug":"tmux-pane-wrapflag"},{"id":"tmux.Client.Activity","name":"Activity","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Activity returns tmux #{client_activity} as time.Time from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1340,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Activity","product":"core","slug":"tmux-client-activity"},{"id":"tmux.Client.CellHeight","name":"CellHeight","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CellHeight returns tmux #{client_cell_height} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1343,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.CellHeight","product":"core","slug":"tmux-client-cellheight"},{"id":"tmux.Client.CellWidth","name":"CellWidth","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CellWidth returns tmux #{client_cell_width} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1346,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.CellWidth","product":"core","slug":"tmux-client-cellwidth"},{"id":"tmux.Client.ControlMode","name":"ControlMode","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ControlMode returns tmux #{client_control_mode} as bool from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1349,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.ControlMode","product":"core","slug":"tmux-client-controlmode"},{"id":"tmux.Client.Created","name":"Created","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Created returns tmux #{client_created} as time.Time from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1352,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Created","product":"core","slug":"tmux-client-created"},{"id":"tmux.Client.Discarded","name":"Discarded","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Discarded returns tmux #{client_discarded} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1355,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Discarded","product":"core","slug":"tmux-client-discarded"},{"id":"tmux.Client.Flags","name":"Flags","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Flags returns tmux #{client_flags} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1358,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Flags","product":"core","slug":"tmux-client-flags"},{"id":"tmux.Client.Height","name":"Height","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Height returns tmux #{client_height} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1361,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Height","product":"core","slug":"tmux-client-height"},{"id":"tmux.Client.KeyTable","name":"KeyTable","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"KeyTable returns tmux #{client_key_table} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1364,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.KeyTable","product":"core","slug":"tmux-client-keytable"},{"id":"tmux.Client.LastSession","name":"LastSession","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"LastSession returns tmux #{client_last_session} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1367,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.LastSession","product":"core","slug":"tmux-client-lastsession"},{"id":"tmux.Client.ModeFormat","name":"ModeFormat","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ModeFormat returns tmux #{client_mode_format} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1370,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.ModeFormat","product":"core","slug":"tmux-client-modeformat"},{"id":"tmux.Client.ProcessPID","name":"ProcessPID","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ProcessPID returns tmux #{client_pid} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1373,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.ProcessPID","product":"core","slug":"tmux-client-processpid"},{"id":"tmux.Client.Prefix","name":"Prefix","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Prefix returns tmux #{client_prefix} as bool from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1376,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Prefix","product":"core","slug":"tmux-client-prefix"},{"id":"tmux.Client.ReadOnly","name":"ReadOnly","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ReadOnly returns tmux #{client_readonly} as bool from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1379,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.ReadOnly","product":"core","slug":"tmux-client-readonly"},{"id":"tmux.Client.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Session returns tmux #{client_session} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1382,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Session","product":"core","slug":"tmux-client-session"},{"id":"tmux.Client.TermFeatures","name":"TermFeatures","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TermFeatures returns tmux #{client_termfeatures} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1385,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.TermFeatures","product":"core","slug":"tmux-client-termfeatures"},{"id":"tmux.Client.TermName","name":"TermName","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TermName returns tmux #{client_termname} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1388,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.TermName","product":"core","slug":"tmux-client-termname"},{"id":"tmux.Client.TermType","name":"TermType","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TermType returns tmux #{client_termtype} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1391,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.TermType","product":"core","slug":"tmux-client-termtype"},{"id":"tmux.Client.TTY","name":"TTY","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TTY returns tmux #{client_tty} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1394,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.TTY","product":"core","slug":"tmux-client-tty"},{"id":"tmux.Client.ProcessUID","name":"ProcessUID","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ProcessUID returns tmux #{client_uid} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1397,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.ProcessUID","product":"core","slug":"tmux-client-processuid"},{"id":"tmux.Client.ProcessUser","name":"ProcessUser","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ProcessUser returns tmux #{client_user} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1400,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.ProcessUser","product":"core","slug":"tmux-client-processuser"},{"id":"tmux.Client.UTF8","name":"UTF8","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"UTF8 returns tmux #{client_utf8} as bool from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1403,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.UTF8","product":"core","slug":"tmux-client-utf8"},{"id":"tmux.Client.Width","name":"Width","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Width returns tmux #{client_width} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1406,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Width","product":"core","slug":"tmux-client-width"},{"id":"tmux.Client.Written","name":"Written","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Written returns tmux #{client_written} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1409,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Written","product":"core","slug":"tmux-client-written"},{"id":"tmux.ErrNotInsideTmux","name":"ErrNotInsideTmux","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrNotInsideTmux identifies missing or malformed tmux discovery variables."},"source":{"file":"tmux/from_env.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrNotInsideTmux","product":"core","slug":"tmux-errnotinsidetmux"},{"id":"tmux.FromEnvError","name":"FromEnvError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"FromEnvError reports which tmux discovery variable was missing or malformed. It never retains or prints the variable's value."},"source":{"file":"tmux/from_env.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FromEnvError","product":"core","slug":"tmux-fromenverror"},{"id":"tmux.FromEnvError.Variable","name":"Variable","kind":"attribute","modifiers":[],"parent":"tmux.FromEnvError","signatures":[],"type":"string","doc":{"summary":"Variable is the discovery variable name, never its value."},"source":{"file":"tmux/from_env.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FromEnvError.Variable","product":"core","slug":"tmux-fromenverror-variable"},{"id":"tmux.FromEnvError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.FromEnvError","signatures":[],"type":"string","doc":{"summary":"Reason describes why the variable cannot identify a tmux resource."},"source":{"file":"tmux/from_env.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FromEnvError.Reason","product":"core","slug":"tmux-fromenverror-reason"},{"id":"tmux.FromEnvError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.FromEnvError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/from_env.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FromEnvError.Error","product":"core","slug":"tmux-fromenverror-error"},{"id":"tmux.FromEnvError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.FromEnvError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes FromEnvError compatible with ErrNotInsideTmux."},"source":{"file":"tmux/from_env.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FromEnvError.Unwrap","product":"core","slug":"tmux-fromenverror-unwrap"},{"id":"tmux.NewServerFromEnv","name":"NewServerFromEnv","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"environment","type":"map[string]string"}],"returns":"(Server, error)"}],"doc":{"summary":"NewServerFromEnv returns a server configured from TMUX without starting tmux. It snapshots the process environment once. A nonnil environment supplies discovery values and overrides that snapshot for later tmux processes; an empty map therefore has no TMUX discovery value. Names follow the platform's environment rules and are case-insensitive on Windows."},"source":{"file":"tmux/from_env.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewServerFromEnv","product":"core","slug":"tmux-newserverfromenv"},{"id":"tmux.PaneFromEnv","name":"PaneFromEnv","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"environment","type":"map[string]string"}],"returns":"(Pane, error)"}],"doc":{"summary":"PaneFromEnv returns the pane identified by TMUX and TMUX_PANE. Nil reads the process environment; a nonnil empty map does not. Environment names are case-insensitive on Windows. It resolves the live hierarchy later through identity-checked tmux queries."},"source":{"file":"tmux/from_env.go","line":70,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneFromEnv","product":"core","slug":"tmux-panefromenv"},{"id":"tmux.WindowFromEnv","name":"WindowFromEnv","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"environment","type":"map[string]string"}],"returns":"(Window, error)"}],"doc":{"summary":"WindowFromEnv returns the window containing the pane identified by the environment. Nil reads the process environment; a nonnil empty map does not."},"source":{"file":"tmux/from_env.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowFromEnv","product":"core","slug":"tmux-windowfromenv"},{"id":"tmux.SessionFromEnv","name":"SessionFromEnv","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"environment","type":"map[string]string"}],"returns":"(Session, error)"}],"doc":{"summary":"SessionFromEnv returns the canonical session containing the environment's pane. Nil reads the process environment; a nonnil empty map does not."},"source":{"file":"tmux/from_env.go","line":84,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionFromEnv","product":"core","slug":"tmux-sessionfromenv"},{"id":"tmux.Server.Sessions","name":"Sessions","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]Session, error)"}],"doc":{"summary":"Sessions materializes the server's sessions. Failures, including [ErrNoServer], remain errors rather than empty results."},"source":{"file":"tmux/hierarchy.go","line":7,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Sessions","product":"core","slug":"tmux-server-sessions"},{"id":"tmux.Server.Windows","name":"Windows","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]Window, error)"}],"doc":{"summary":"Windows materializes one record per winlink. Failures, including [ErrNoServer], remain errors rather than empty results."},"source":{"file":"tmux/hierarchy.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Windows","product":"core","slug":"tmux-server-windows"},{"id":"tmux.Server.Panes","name":"Panes","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]Pane, error)"}],"doc":{"summary":"Panes materializes pane records for every winlink. Failures, including [ErrNoServer], remain errors rather than empty results."},"source":{"file":"tmux/hierarchy.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Panes","product":"core","slug":"tmux-server-panes"},{"id":"tmux.Server.Clients","name":"Clients","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]Client, error)"}],"doc":{"summary":"Clients materializes attached clients. Failures, including [ErrNoServer], remain errors rather than empty results."},"source":{"file":"tmux/hierarchy.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Clients","product":"core","slug":"tmux-server-clients"},{"id":"tmux.SetHooksOptions","name":"SetHooksOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetHooksOptions controls a bulk hook replacement. Its zero value preserves existing indices before applying the supplied sparse values."},"source":{"file":"tmux/hook_runtime.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetHooksOptions","product":"core","slug":"tmux-sethooksoptions"},{"id":"tmux.SetHooksOptions.ClearExisting","name":"ClearExisting","kind":"attribute","modifiers":[],"parent":"tmux.SetHooksOptions","signatures":[],"type":"bool","doc":{"summary":"ClearExisting unsets every existing index before applying Values."},"source":{"file":"tmux/hook_runtime.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetHooksOptions.ClearExisting","product":"core","slug":"tmux-sethooksoptions-clearexisting"},{"id":"tmux.SetHooksResult","name":"SetHooksResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetHooksResult reports only side effects confirmed before return."},"source":{"file":"tmux/hook_runtime.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetHooksResult","product":"core","slug":"tmux-sethooksresult"},{"id":"tmux.SetHooksResult.Cleared","name":"Cleared","kind":"attribute","modifiers":[],"parent":"tmux.SetHooksResult","signatures":[],"type":"bool","doc":{"summary":"Cleared reports that all existing hook indices were confirmed cleared."},"source":{"file":"tmux/hook_runtime.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetHooksResult.Cleared","product":"core","slug":"tmux-sethooksresult-cleared"},{"id":"tmux.SetHooksResult.AppliedIndices","name":"AppliedIndices","kind":"attribute","modifiers":[],"parent":"tmux.SetHooksResult","signatures":[],"type":"[]int","doc":{"summary":"AppliedIndices is an owned ascending list of indices confirmed applied."},"source":{"file":"tmux/hook_runtime.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetHooksResult.AppliedIndices","product":"core","slug":"tmux-sethooksresult-appliedindices"},{"id":"tmux.GlobalSessionScope.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ServerHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known global session-scope hooks, including inherited values. A read failure is returned rather than answered with zero values."},"source":{"file":"tmux/hook_runtime.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.Hooks","product":"core","slug":"tmux-globalsessionscope-hooks"},{"id":"tmux.GlobalWindowScope.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(WindowHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known global window hooks, including defaults. A read failure is returned rather than answered with zero values; context errors propagate."},"source":{"file":"tmux/hook_runtime.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.Hooks","product":"core","slug":"tmux-globalwindowscope-hooks"},{"id":"tmux.Session.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(SessionHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known hooks at this stable session target, including inherited values. A read failure is returned rather than answered with zero values."},"source":{"file":"tmux/hook_runtime.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Hooks","product":"core","slug":"tmux-session-hooks"},{"id":"tmux.Window.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(WindowHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known hooks at this exact window target, including inherited values. The receiver's exact linked session context controls tmux format evaluation. A read failure is returned rather than answered with zero values."},"source":{"file":"tmux/hook_runtime.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Hooks","product":"core","slug":"tmux-window-hooks"},{"id":"tmux.Pane.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(PaneHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known hooks at this exact pane target, including inherited values. The receiver's exact linked session context controls tmux format evaluation. A read failure is returned rather than answered with zero values."},"source":{"file":"tmux/hook_runtime.go","line":111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Hooks","product":"core","slug":"tmux-pane-hooks"},{"id":"tmux.GlobalSessionScope.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact global session-scope hook value. A successful string is caller-owned; ok reports presence. Targeted reads do not use list leniency, and completed failures return a secret-safe option error. An unindexed empty hook array is ambiguous; use Hooks for typed presence."},"source":{"file":"tmux/hook_runtime.go","line":134,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.RawHook","product":"core","slug":"tmux-globalsessionscope-rawhook"},{"id":"tmux.GlobalWindowScope.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact global window-hook value. A successful string is caller-owned; ok reports presence and completed failures are returned. An unindexed empty hook array is ambiguous; use Hooks for typed presence."},"source":{"file":"tmux/hook_runtime.go","line":142,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.RawHook","product":"core","slug":"tmux-globalwindowscope-rawhook"},{"id":"tmux.Session.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact session hook value at this stable session target. A successful string is caller-owned; ok reports presence and completed failures are returned. An unindexed empty hook array is ambiguous; use Hooks for typed presence."},"source":{"file":"tmux/hook_runtime.go","line":153,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.RawHook","product":"core","slug":"tmux-session-rawhook"},{"id":"tmux.Window.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact window hook value at this exact window target. A successful string is caller-owned; the receiver's exact linked session context controls tmux format evaluation, and completed failures are returned."},"source":{"file":"tmux/hook_runtime.go","line":164,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.RawHook","product":"core","slug":"tmux-window-rawhook"},{"id":"tmux.Pane.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact pane hook value at this exact pane target. A successful string is caller-owned; the receiver's exact linked session context controls tmux format evaluation, and completed failures are returned."},"source":{"file":"tmux/hook_runtime.go","line":175,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.RawHook","product":"core","slug":"tmux-pane-rawhook"},{"id":"tmux.GlobalSessionScope.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a global session-scope hook without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":186,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetHook","product":"core","slug":"tmux-globalsessionscope-sethook"},{"id":"tmux.GlobalWindowScope.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a global window hook without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":193,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetHook","product":"core","slug":"tmux-globalwindowscope-sethook"},{"id":"tmux.Session.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a session hook at this stable session target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":208,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetHook","product":"core","slug":"tmux-session-sethook"},{"id":"tmux.Window.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a window hook at this exact window target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":219,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetHook","product":"core","slug":"tmux-window-sethook"},{"id":"tmux.Pane.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a pane hook at this exact pane target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":230,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetHook","product":"core","slug":"tmux-pane-sethook"},{"id":"tmux.GlobalSessionScope.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a global session-scope hook without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":241,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.AppendHook","product":"core","slug":"tmux-globalsessionscope-appendhook"},{"id":"tmux.GlobalWindowScope.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a command to a global window hook without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":248,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.AppendHook","product":"core","slug":"tmux-globalwindowscope-appendhook"},{"id":"tmux.Session.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a session hook at this stable session target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":263,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.AppendHook","product":"core","slug":"tmux-session-appendhook"},{"id":"tmux.Window.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a window hook at this exact window target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":274,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.AppendHook","product":"core","slug":"tmux-window-appendhook"},{"id":"tmux.Pane.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a pane hook at this exact pane target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":285,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AppendHook","product":"core","slug":"tmux-pane-appendhook"},{"id":"tmux.GlobalSessionScope.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching global session-scope hook index without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the unset."},"source":{"file":"tmux/hook_runtime.go","line":296,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.UnsetHook","product":"core","slug":"tmux-globalsessionscope-unsethook"},{"id":"tmux.GlobalWindowScope.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching global window-hook index without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the unset."},"source":{"file":"tmux/hook_runtime.go","line":303,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.UnsetHook","product":"core","slug":"tmux-globalwindowscope-unsethook"},{"id":"tmux.Session.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching session hook index at this stable session target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the unset was accepted."},"source":{"file":"tmux/hook_runtime.go","line":318,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.UnsetHook","product":"core","slug":"tmux-session-unsethook"},{"id":"tmux.Window.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching window hook index at this exact window target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the unset was accepted."},"source":{"file":"tmux/hook_runtime.go","line":329,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.UnsetHook","product":"core","slug":"tmux-window-unsethook"},{"id":"tmux.Pane.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching pane hook index at this exact pane target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the unset was accepted."},"source":{"file":"tmux/hook_runtime.go","line":340,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.UnsetHook","product":"core","slug":"tmux-pane-unsethook"},{"id":"tmux.GlobalSessionScope.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one global hook directly. It intentionally performs no racy target preflight; stale targets and global execution context remain tmux-defined. Completed failures are secret-safe option errors; cancellation does not prove hook delivery or execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":352,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.RunHook","product":"core","slug":"tmux-globalsessionscope-runhook"},{"id":"tmux.GlobalWindowScope.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one global window hook directly. It targets global window scope rather than a receiver, returns secret-safe option errors for completed failures, and cancellation does not prove hook delivery or execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":360,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.RunHook","product":"core","slug":"tmux-globalwindowscope-runhook"},{"id":"tmux.Session.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one session hook directly at this stable target. It intentionally performs no racy liveness preflight after validation. Completed failures are secret-safe option errors; cancellation does not prove execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":376,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.RunHook","product":"core","slug":"tmux-session-runhook"},{"id":"tmux.Window.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one window hook directly at this exact target. The receiver's exact linked session context controls tmux format evaluation; no racy preflight is issued. Completed failures are secret-safe option errors; cancellation does not prove execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":388,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.RunHook","product":"core","slug":"tmux-window-runhook"},{"id":"tmux.Pane.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one pane hook directly at this exact target. The receiver's exact linked session context controls tmux format evaluation; no racy preflight is issued. Completed failures are secret-safe option errors; cancellation does not prove execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":400,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.RunHook","product":"core","slug":"tmux-pane-runhook"},{"id":"tmux.GlobalSessionScope.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed global session-scope hook commands in ascending order. With ClearExisting it confirms clearing before applying sparse Values. It stops at the first failure without rollback; the returned result reports only confirmed partial progress and owns AppliedIndices. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":413,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetHooks","product":"core","slug":"tmux-globalsessionscope-sethooks"},{"id":"tmux.GlobalWindowScope.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed global window-hook commands in ascending order. With ClearExisting it confirms clearing before applying sparse Values, stops at the first failure without rollback, and reports confirmed progress. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":426,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetHooks","product":"core","slug":"tmux-globalwindowscope-sethooks"},{"id":"tmux.Session.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed session hook commands in ascending order at this handle's stable session target. With ClearExisting it confirms clearing first, stops at the first failure without rollback, and reports confirmed partial progress. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":448,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetHooks","product":"core","slug":"tmux-session-sethooks"},{"id":"tmux.Window.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed window hook commands in ascending order at this handle's exact window target. With ClearExisting it confirms clearing first, stops at the first failure without rollback, and reports confirmed progress. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":465,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetHooks","product":"core","slug":"tmux-window-sethooks"},{"id":"tmux.Pane.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed pane hook commands in ascending order at this handle's exact pane target. With ClearExisting it confirms clearing first, stops at the first failure without rollback, and reports confirmed progress. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":482,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetHooks","product":"core","slug":"tmux-pane-sethooks"},{"id":"tmux.ErrDaemonReplaced","name":"ErrDaemonReplaced","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrDaemonReplaced identifies an operation refused because the tmux server instance that produced a materialized value no longer occupies its socket."},"source":{"file":"tmux/identity.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrDaemonReplaced","product":"core","slug":"tmux-errdaemonreplaced"},{"id":"tmux.Server.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"other","type":"Server"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether both handles currently select the same socket path. It evaluates relative paths and environment-dependent named and default sockets against each handle's frozen binding."},"source":{"file":"tmux/identity.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Equal","product":"core","slug":"tmux-server-equal"},{"id":"tmux.Server.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns a concise representation of the server selector."},"source":{"file":"tmux/identity.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.String","product":"core","slug":"tmux-server-string"},{"id":"tmux.Session.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"other","type":"Session"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether two session records carry the same stable ID and tmux server provenance."},"source":{"file":"tmux/identity.go","line":59,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Equal","product":"core","slug":"tmux-session-equal"},{"id":"tmux.Session.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the session's stable ID and queried name."},"source":{"file":"tmux/identity.go","line":64,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.String","product":"core","slug":"tmux-session-string"},{"id":"tmux.Window.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"other","type":"Window"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether two window records carry the same stable window ID. It intentionally collapses linked-session views with different sessions or indexes; use SessionID, WindowID, and WindowIndex for exact view identity."},"source":{"file":"tmux/identity.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Equal","product":"core","slug":"tmux-window-equal"},{"id":"tmux.Window.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the winlink identity and its materialized parent, when present."},"source":{"file":"tmux/identity.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.String","product":"core","slug":"tmux-window-string"},{"id":"tmux.Pane.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"other","type":"Pane"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether two pane records carry the same stable pane ID. It intentionally collapses linked-session views; a pane's exact view identity includes SessionID, WindowID, WindowIndex, and PaneID."},"source":{"file":"tmux/identity.go","line":91,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Equal","product":"core","slug":"tmux-pane-equal"},{"id":"tmux.Pane.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the pane identity and its materialized parent, when present."},"source":{"file":"tmux/identity.go","line":96,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.String","product":"core","slug":"tmux-pane-string"},{"id":"tmux.Client.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[{"name":"other","type":"Client"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether two clients carry the same stable client name and tmux server provenance."},"source":{"file":"tmux/identity.go","line":106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Equal","product":"core","slug":"tmux-client-equal"},{"id":"tmux.Client.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the client's stable name."},"source":{"file":"tmux/identity.go","line":111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.String","product":"core","slug":"tmux-client-string"},{"id":"tmux.ErrInvalidRequest","name":"ErrInvalidRequest","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidRequest identifies lifecycle options rejected before execution."},"source":{"file":"tmux/lifecycle.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidRequest","product":"core","slug":"tmux-errinvalidrequest"},{"id":"tmux.ErrInvalidCommandOutput","name":"ErrInvalidCommandOutput","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidCommandOutput identifies malformed identity output from tmux."},"source":{"file":"tmux/lifecycle.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidCommandOutput","product":"core","slug":"tmux-errinvalidcommandoutput"},{"id":"tmux.PaneDirection","name":"PaneDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneDirection selects where a tiled pane is created or moved on tmux 3.2a or later. Its zero value places the pane below the target."},"source":{"file":"tmux/lifecycle.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneDirection","product":"core","slug":"tmux-panedirection"},{"id":"tmux.PaneDirectionBelow","name":"PaneDirectionBelow","kind":"constant","modifiers":[],"signatures":[],"type":"PaneDirection","doc":{"summary":"PaneDirectionBelow places the pane below the target."},"source":{"file":"tmux/lifecycle.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneDirectionBelow","product":"core","slug":"tmux-panedirectionbelow"},{"id":"tmux.PaneDirectionAbove","name":"PaneDirectionAbove","kind":"constant","modifiers":[],"signatures":[],"type":"PaneDirection","doc":{"summary":"PaneDirectionAbove places the pane above the target."},"source":{"file":"tmux/lifecycle.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneDirectionAbove","product":"core","slug":"tmux-panedirectionabove"},{"id":"tmux.PaneDirectionRight","name":"PaneDirectionRight","kind":"constant","modifiers":[],"signatures":[],"type":"PaneDirection","doc":{"summary":"PaneDirectionRight places the pane to the right of the target."},"source":{"file":"tmux/lifecycle.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneDirectionRight","product":"core","slug":"tmux-panedirectionright"},{"id":"tmux.PaneDirectionLeft","name":"PaneDirectionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"PaneDirection","doc":{"summary":"PaneDirectionLeft places the pane to the left of the target."},"source":{"file":"tmux/lifecycle.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneDirectionLeft","product":"core","slug":"tmux-panedirectionleft"},{"id":"tmux.SessionKillRequest","name":"SessionKillRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionKillRequest configures kill-session on tmux 3.2a or later. Its zero value destroys the receiver session. AllExcept destroys other sessions instead, while ClearAlerts is non-destructive. AllExcept, ClearAlerts, and Group are mutually exclusive because tmux applies a hidden precedence when more than one mode is supplied; the package rejects those combinations before execution. Group's compatibility behavior is documented on that field."},"source":{"file":"tmux/lifecycle_kill.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionKillRequest","product":"core","slug":"tmux-sessionkillrequest"},{"id":"tmux.SessionKillRequest.AllExcept","name":"AllExcept","kind":"attribute","modifiers":[],"parent":"tmux.SessionKillRequest","signatures":[],"type":"bool","doc":{"summary":"AllExcept terminates every other session and detaches their clients while preserving the receiver session."},"source":{"file":"tmux/lifecycle_kill.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionKillRequest.AllExcept","product":"core","slug":"tmux-sessionkillrequest-allexcept"},{"id":"tmux.SessionKillRequest.ClearAlerts","name":"ClearAlerts","kind":"attribute","modifiers":[],"parent":"tmux.SessionKillRequest","signatures":[],"type":"bool","doc":{"summary":"ClearAlerts clears bell, activity, and silence alerts in every window linked to the receiver without destroying a session or detaching its clients."},"source":{"file":"tmux/lifecycle_kill.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionKillRequest.ClearAlerts","product":"core","slug":"tmux-sessionkillrequest-clearalerts"},{"id":"tmux.SessionKillRequest.Group","name":"Group","kind":"attribute","modifiers":[],"parent":"tmux.SessionKillRequest","signatures":[],"type":"bool","doc":{"summary":"Group terminates every session in the receiver's group and detaches their clients. It requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/lifecycle_kill.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionKillRequest.Group","product":"core","slug":"tmux-sessionkillrequest-group"},{"id":"tmux.KillWindowRequest","name":"KillWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"KillWindowRequest selects a window for [Session.KillWindow] on tmux 3.2a or later. A zero request kills the receiver session's current window, and Index is scoped to that session. Target is unrestricted tmux target syntax and may select a window in another session. Target and Index are mutually exclusive and are checked before execution. Pointer values are read during the call and are not retained; callers must not mutate them concurrently. A nil pointer omits its selector, while a nonnil pointer is explicit even when Target points to an empty string."},"source":{"file":"tmux/lifecycle_kill.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.KillWindowRequest","product":"core","slug":"tmux-killwindowrequest"},{"id":"tmux.KillWindowRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.KillWindowRequest","signatures":[],"type":"*string","doc":{"summary":"Target is passed through as unrestricted tmux target syntax when nonnil."},"source":{"file":"tmux/lifecycle_kill.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.KillWindowRequest.Target","product":"core","slug":"tmux-killwindowrequest-target"},{"id":"tmux.KillWindowRequest.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.KillWindowRequest","signatures":[],"type":"*int","doc":{"summary":"Index selects a winlink index within the receiver session when nonnil."},"source":{"file":"tmux/lifecycle_kill.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.KillWindowRequest.Index","product":"core","slug":"tmux-killwindowrequest-index"},{"id":"tmux.Server.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill terminates the configured tmux server and all of its sessions, windows, panes, and clients. After a completed failed kill, a liveness probe makes repeated calls harmless when no daemon answers. Transport or context errors can be delivery-ambiguous; no rollback is attempted.","body":"tmux leaves the socket file in place, so cleanup that waits for the path to\ndisappear does not finish. Use [Server.IsAlive] to observe the daemon, and\nremove a socket path this process chose itself."},"source":{"file":"tmux/lifecycle_kill.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Kill","product":"core","slug":"tmux-server-kill"},{"id":"tmux.Server.KillSession","name":"KillSession","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"target","type":"string"}],"returns":"error"}],"doc":{"summary":"KillSession terminates the session selected by tmux target syntax. Pattern and prefix matching are deliberately left to tmux. Completed nonzero exits without stderr are ignored. Transport and context errors are delivery-ambiguous."},"source":{"file":"tmux/lifecycle_kill.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.KillSession","product":"core","slug":"tmux-server-killsession"},{"id":"tmux.Session.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill destroys the receiver session and removes its winlinks. Ordinary attached clients detach; on tmux 3.6 or later, clients carrying no-detach-on-destroy move to another session when one exists. A window with no remaining links and all of that window's panes are also destroyed. The materialized receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored. Transport errors are delivery-ambiguous. Kill is equivalent to [Session.KillWith] with a zero [SessionKillRequest]."},"source":{"file":"tmux/lifecycle_kill.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Kill","product":"core","slug":"tmux-session-kill"},{"id":"tmux.Session.KillWith","name":"KillWith","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SessionKillRequest"}],"returns":"error"}],"doc":{"summary":"KillWith applies one kill-session mode without refreshing the materialized receiver. The zero request destroys the receiver; AllExcept destroys every other session while preserving the receiver and its current window; ClearAlerts only clears alerts in windows linked to the receiver and leaves sessions, winlinks, panes, client attachments, and current-window selections unchanged. Destroying a session handles clients as [Session.Kill] describes and removes its winlinks; windows left without links and their panes are also destroyed. Group destroys the receiver's group and requires tmux 3.7; on older versions it follows [UnsupportedPolicy].","body":"The three modes are mutually exclusive. Only stderr makes a completed command\na [CommandError]; nonzero exits without stderr are ignored. Transport errors\nare delivery-ambiguous."},"source":{"file":"tmux/lifecycle_kill.go","line":111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.KillWith","product":"core","slug":"tmux-session-killwith"},{"id":"tmux.Session.KillWindow","name":"KillWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"KillWindowRequest"}],"returns":"error"}],"doc":{"summary":"KillWindow destroys one stable window. When Target and Index are nil it selects the receiver session's current window, and Index selects a winlink in that session. A nonnil Target is forwarded as unrestricted tmux target syntax and may select a window in another session. The selected stable window is removed from every session and its panes are destroyed. Affected sessions preserve their current selection unless this window was current, in which case they select another. A session left without windows is destroyed; [Session.Kill] describes how tmux handles its clients.","body":"Target and Index are mutually exclusive. The receiver is not refreshed. Only\nstderr makes a completed command a [CommandError]; nonzero exits without\nstderr are ignored. Transport errors are delivery-ambiguous."},"source":{"file":"tmux/lifecycle_kill.go","line":169,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.KillWindow","product":"core","slug":"tmux-session-killwindow"},{"id":"tmux.Window.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill destroys the stable window selected by the receiver's WindowID, removes all of its winlinks, and destroys its panes. Affected sessions preserve their current selection unless this window was current, in which case they select another. A session left without windows is destroyed; [Session.Kill] describes how tmux handles its clients. The receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored."},"source":{"file":"tmux/lifecycle_kill.go","line":205,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Kill","product":"core","slug":"tmux-window-kill"},{"id":"tmux.Window.KillOthers","name":"KillOthers","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"KillOthers destroys every other stable window selected through the receiver's exact session and leaves the receiver as that session's current and only window. Links in other sessions are not selected merely because they share the receiver's [WindowID], but every selected stable window is removed from all sessions. Other affected sessions preserve their current selection unless a destroyed window was current, in which case they select another. A session left without windows is destroyed; [Session.Kill] describes how tmux handles its clients. The receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored."},"source":{"file":"tmux/lifecycle_kill.go","line":220,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.KillOthers","product":"core","slug":"tmux-window-killothers"},{"id":"tmux.Pane.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill destroys the receiver pane through its exact linked-pane target. If panes remain and the receiver was active, tmux selects another active pane. If this was the last pane, tmux also destroys the window and removes all of its winlinks. Affected sessions preserve their current selection unless the destroyed window was current, in which case they select another. A session left without windows is destroyed; [Session.Kill] describes how tmux handles its clients. The receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored."},"source":{"file":"tmux/lifecycle_kill.go","line":237,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Kill","product":"core","slug":"tmux-pane-kill"},{"id":"tmux.Pane.KillOthers","name":"KillOthers","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"KillOthers destroys every other pane in the receiver's stable window and leaves the receiver as its sole active pane. It does not select the exact winlink as its session's current window or promise client focus, and it does not destroy a window or session. The receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored."},"source":{"file":"tmux/lifecycle_kill.go","line":247,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.KillOthers","product":"core","slug":"tmux-pane-killothers"},{"id":"tmux.Server.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"id","type":"SessionID"}],"returns":"(Session, error)"}],"doc":{"summary":"Session performs a canonical live lookup of id and returns a newly materialized record. Use [Session.Refresh] when beginning from a record."},"source":{"file":"tmux/lookup.go","line":10,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Session","product":"core","slug":"tmux-server-session"},{"id":"tmux.Server.SessionByName","name":"SessionByName","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(Session, error)"}],"doc":{"summary":"SessionByName performs a live lookup of the session tmux knows by name and returns a newly materialized record. A name no session holds reports [ErrNotFound].","body":"tmux keeps session names unique, so a name identifies one session for as\nlong as it keeps it. A [SessionID] does not change, which is why the records\nthis package hands back carry one and [Server.Session] takes one; a name is\nwhat a person types and what a workspace file records."},"source":{"file":"tmux/lookup.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SessionByName","product":"core","slug":"tmux-server-sessionbyname"},{"id":"tmux.Server.Window","name":"Window","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"id","type":"WindowID"}],"returns":"(Window, error)"}],"doc":{"summary":"Window performs a canonical live lookup of id using tmux's canonical session and returns a newly materialized record. It does not preserve a linked-session view; use [Window.ResolveSession] for that exact relationship."},"source":{"file":"tmux/lookup.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Window","product":"core","slug":"tmux-server-window"},{"id":"tmux.Server.Pane","name":"Pane","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"id","type":"PaneID"}],"returns":"(Pane, error)"}],"doc":{"summary":"Pane performs a canonical live lookup of id using tmux's canonical session and returns a newly materialized record. It does not preserve a linked-session view; use [Pane.ResolveWindow] for that exact relationship."},"source":{"file":"tmux/lookup.go","line":78,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Pane","product":"core","slug":"tmux-server-pane"},{"id":"tmux.Server.Client","name":"Client","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"ClientName"}],"returns":"(Client, error)"}],"doc":{"summary":"Client performs a canonical live lookup of name and returns a new record."},"source":{"file":"tmux/lookup.go","line":93,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Client","product":"core","slug":"tmux-server-client"},{"id":"tmux.Session.Refresh","name":"Refresh","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Session, error)"}],"doc":{"summary":"Refresh performs a canonical live lookup without mutating the receiver."},"source":{"file":"tmux/lookup.go","line":108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Refresh","product":"core","slug":"tmux-session-refresh"},{"id":"tmux.Window.Refresh","name":"Refresh","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"Refresh performs a canonical live lookup for the window's stable ID and returns a new record without mutating the receiver. It does not preserve a linked-session view; use [Window.ResolveSession] for exact relationships."},"source":{"file":"tmux/lookup.go","line":115,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Refresh","product":"core","slug":"tmux-window-refresh"},{"id":"tmux.Pane.Refresh","name":"Refresh","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Pane, error)"}],"doc":{"summary":"Refresh performs a canonical live lookup for the pane's stable ID and returns a new record without mutating the receiver. It does not preserve a linked-session view; use [Pane.ResolveWindow] for exact relationships."},"source":{"file":"tmux/lookup.go","line":122,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Refresh","product":"core","slug":"tmux-pane-refresh"},{"id":"tmux.Client.Refresh","name":"Refresh","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Client, error)"}],"doc":{"summary":"Refresh performs a canonical live lookup without mutating the receiver."},"source":{"file":"tmux/lookup.go","line":127,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Refresh","product":"core","slug":"tmux-client-refresh"},{"id":"tmux.FormatValues.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the format expansions as tmux returned them. Nothing decodes: [json.Unmarshal] into this type reports no error and changes nothing, because every field is unexported."},"source":{"file":"tmux/marshal.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FormatValues.MarshalJSON","product":"core","slug":"tmux-formatvalues-marshaljson"},{"id":"tmux.Session.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the session's identity and the format expansions tmux returned for it, under \"formats\". Nothing decodes: a decoded record would carry no [Server], so it could name a session it could never act on, and [json.Unmarshal] into this type reports no error and changes nothing."},"source":{"file":"tmux/marshal.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.MarshalJSON","product":"core","slug":"tmux-session-marshaljson"},{"id":"tmux.Window.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the window's identity, its place in the hierarchy, and the format expansions tmux returned for it. Nothing decodes; see [Session.MarshalJSON]."},"source":{"file":"tmux/marshal.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.MarshalJSON","product":"core","slug":"tmux-window-marshaljson"},{"id":"tmux.Pane.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the pane's identity, its place in the hierarchy, and the format expansions tmux returned for it. Nothing decodes; see [Session.MarshalJSON]."},"source":{"file":"tmux/marshal.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.MarshalJSON","product":"core","slug":"tmux-pane-marshaljson"},{"id":"tmux.Client.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the client's name and the format expansions tmux returned for it. Nothing decodes; see [Session.MarshalJSON]."},"source":{"file":"tmux/marshal.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.MarshalJSON","product":"core","slug":"tmux-client-marshaljson"},{"id":"tmux.Snapshot.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the snapshot's tmux version and the records it holds. A kind it listed encodes as an array, empty when tmux reported none; a kind it never listed is absent. Those are different answers, and one field cannot spell both, which is why the arrays are pointers here. Nothing decodes; see [Session.MarshalJSON]."},"source":{"file":"tmux/marshal.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.MarshalJSON","product":"core","slug":"tmux-snapshot-marshaljson"},{"id":"tmux.SessionID","name":"SessionID","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionID is tmux's stable session identifier, including its $ sigil. The zero value is not a usable tmux target."},"source":{"file":"tmux/model.go","line":5,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionID","product":"core","slug":"tmux-sessionid"},{"id":"tmux.SessionID.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.SessionID","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the tmux identifier verbatim."},"source":{"file":"tmux/model.go","line":8,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionID.String","product":"core","slug":"tmux-sessionid-string"},{"id":"tmux.WindowID","name":"WindowID","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowID is tmux's stable window identifier, including its @ sigil. It does not distinguish linked-session views; the zero value is not a usable target."},"source":{"file":"tmux/model.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowID","product":"core","slug":"tmux-windowid"},{"id":"tmux.WindowID.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.WindowID","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the tmux identifier verbatim."},"source":{"file":"tmux/model.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowID.String","product":"core","slug":"tmux-windowid-string"},{"id":"tmux.PaneID","name":"PaneID","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneID is tmux's stable pane identifier, including its % sigil. It does not distinguish linked-session views; the zero value is not a usable target."},"source":{"file":"tmux/model.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneID","product":"core","slug":"tmux-paneid"},{"id":"tmux.PaneID.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneID","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the tmux identifier verbatim."},"source":{"file":"tmux/model.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneID.String","product":"core","slug":"tmux-paneid-string"},{"id":"tmux.ClientName","name":"ClientName","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClientName is tmux's stable client name, normally its terminal path. The zero value is not a usable tmux target."},"source":{"file":"tmux/model.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientName","product":"core","slug":"tmux-clientname"},{"id":"tmux.ClientName.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ClientName","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the tmux client name verbatim."},"source":{"file":"tmux/model.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClientName.String","product":"core","slug":"tmux-clientname-string"},{"id":"tmux.Session","name":"Session","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Session is one materialized tmux session record. It is normally returned by [Server.Snapshot], [Server.Session], or [Session.Refresh]. A zero Session is not a usable tmux target."},"source":{"file":"tmux/model.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session","product":"core","slug":"tmux-session"},{"id":"tmux.Session.ID","name":"ID","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"SessionID"}],"doc":{"summary":"ID returns the stable tmux identity of this session."},"source":{"file":"tmux/model.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ID","product":"core","slug":"tmux-session-id"},{"id":"tmux.Session.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the immutable configured handle that produced the session."},"source":{"file":"tmux/model.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Server","product":"core","slug":"tmux-session-server"},{"id":"tmux.Session.Windows","name":"Windows","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"([]Window, bool)"}],"doc":{"summary":"Windows returns newly allocated shallow copies of this snapshot record's winlink views, and reports whether the receiver carries relations at all.","body":"It never queries tmux. [Server.Snapshot] and the resolvers carry relations; a\ntargeted lookup, refresh, or creation reports false rather than an empty\nrelation. Use [Session.SearchWindows] for current live windows."},"source":{"file":"tmux/model.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Windows","product":"core","slug":"tmux-session-windows"},{"id":"tmux.Session.Panes","name":"Panes","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"([]Pane, bool)"}],"doc":{"summary":"Panes returns newly allocated shallow copies of this snapshot record's pane views, and reports whether the receiver carries relations at all.","body":"It never queries tmux. [Server.Snapshot] and the resolvers carry relations; a\ntargeted lookup, refresh, or creation reports false rather than an empty\nrelation. Use [Session.SearchPanes] for current live panes."},"source":{"file":"tmux/model.go","line":75,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Panes","product":"core","slug":"tmux-session-panes"},{"id":"tmux.Window","name":"Window","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Window is one materialized (session, index, window) winlink record. It is normally returned by [Server.Snapshot], [Server.Window], or [Window.Refresh]. A zero Window is not a usable tmux target."},"source":{"file":"tmux/model.go","line":89,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window","product":"core","slug":"tmux-window"},{"id":"tmux.Window.SessionID","name":"SessionID","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"SessionID"}],"doc":{"summary":"SessionID returns the linked session containing this view."},"source":{"file":"tmux/model.go","line":99,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SessionID","product":"core","slug":"tmux-window-sessionid"},{"id":"tmux.Window.ID","name":"ID","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"WindowID"}],"doc":{"summary":"ID returns the underlying stable tmux window identity."},"source":{"file":"tmux/model.go","line":102,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ID","product":"core","slug":"tmux-window-id"},{"id":"tmux.Window.Index","name":"Index","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Index returns this window's index in its linked session. It returns -1 for a partial Window whose exact winlink has not been materialized."},"source":{"file":"tmux/model.go","line":106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Index","product":"core","slug":"tmux-window-index"},{"id":"tmux.Window.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the configured handle that produced the window."},"source":{"file":"tmux/model.go","line":109,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Server","product":"core","slug":"tmux-window-server"},{"id":"tmux.Window.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(Session, bool)"}],"doc":{"summary":"Session returns this view's parent record when it remains in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Session","product":"core","slug":"tmux-window-session"},{"id":"tmux.Window.Panes","name":"Panes","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"([]Pane, bool)"}],"doc":{"summary":"Panes returns newly allocated shallow copies of panes for this exact winlink, and reports whether the receiver carries relations at all.","body":"It never queries tmux. [Server.Snapshot], the resolvers, and\n[Session.NewWindow] carry relations; a targeted lookup or refresh reports\nfalse instead. Use [Window.SearchPanes] for current live panes."},"source":{"file":"tmux/model.go","line":135,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Panes","product":"core","slug":"tmux-window-panes"},{"id":"tmux.Pane","name":"Pane","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Pane is one materialized pane record within a specific winlink. It is normally returned by [Server.Snapshot], [Server.Pane], or [Pane.Refresh]. A zero Pane is not a usable tmux target."},"source":{"file":"tmux/model.go","line":150,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane","product":"core","slug":"tmux-pane"},{"id":"tmux.Pane.SessionID","name":"SessionID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"SessionID"}],"doc":{"summary":"SessionID returns the linked session containing this pane view."},"source":{"file":"tmux/model.go","line":162,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SessionID","product":"core","slug":"tmux-pane-sessionid"},{"id":"tmux.Pane.WindowID","name":"WindowID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"WindowID"}],"doc":{"summary":"WindowID returns the underlying stable tmux window identity."},"source":{"file":"tmux/model.go","line":165,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.WindowID","product":"core","slug":"tmux-pane-windowid"},{"id":"tmux.Pane.WindowIndex","name":"WindowIndex","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"WindowIndex returns this pane view's window index in its linked session."},"source":{"file":"tmux/model.go","line":168,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.WindowIndex","product":"core","slug":"tmux-pane-windowindex"},{"id":"tmux.Pane.ID","name":"ID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"PaneID"}],"doc":{"summary":"ID returns the stable tmux pane identity."},"source":{"file":"tmux/model.go","line":171,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ID","product":"core","slug":"tmux-pane-id"},{"id":"tmux.Pane.Index","name":"Index","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Index returns the pane's index in its exact window view. Unlike the materialized format accessors it sits beside, it returns a plain int, because a pane record always carries the index tmux placed it at."},"source":{"file":"tmux/model.go","line":176,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Index","product":"core","slug":"tmux-pane-index"},{"id":"tmux.Pane.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the configured handle that produced the pane."},"source":{"file":"tmux/model.go","line":179,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Server","product":"core","slug":"tmux-pane-server"},{"id":"tmux.Pane.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(Session, bool)"}],"doc":{"summary":"Session returns this view's parent record when it remains in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":188,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Session","product":"core","slug":"tmux-pane-session"},{"id":"tmux.Pane.Window","name":"Window","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(Window, bool)"}],"doc":{"summary":"Window returns this pane's exact winlink record when it remains in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":201,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Window","product":"core","slug":"tmux-pane-window"},{"id":"tmux.Client","name":"Client","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Client is one materialized tmux client record. It is normally returned by [Server.Snapshot], [Server.Client], or [Client.Refresh]. A zero Client is not a usable tmux target."},"source":{"file":"tmux/model.go","line":216,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client","product":"core","slug":"tmux-client"},{"id":"tmux.Client.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the configured handle that produced the client."},"source":{"file":"tmux/model.go","line":235,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Server","product":"core","slug":"tmux-client-server"},{"id":"tmux.Client.Name","name":"Name","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"ClientName"}],"doc":{"summary":"Name returns the stable tmux name of this client."},"source":{"file":"tmux/model.go","line":238,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.Name","product":"core","slug":"tmux-client-name"},{"id":"tmux.Client.AttachedSession","name":"AttachedSession","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(Session, bool)"}],"doc":{"summary":"AttachedSession returns the materialized attached session, if present in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":242,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.AttachedSession","product":"core","slug":"tmux-client-attachedsession"},{"id":"tmux.Client.AttachedWindow","name":"AttachedWindow","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(Window, bool)"}],"doc":{"summary":"AttachedWindow returns the client's exact materialized winlink, if present in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":255,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.AttachedWindow","product":"core","slug":"tmux-client-attachedwindow"},{"id":"tmux.Client.AttachedPane","name":"AttachedPane","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(Pane, bool)"}],"doc":{"summary":"AttachedPane returns the client's exact materialized pane view, if present in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":273,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Client.AttachedPane","product":"core","slug":"tmux-client-attachedpane"},{"id":"tmux.NotificationStream","name":"NotificationStream","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NotificationStream owns one observation-only control client attached to a session. It yields tmux notifications in wire order and must be closed. Before tmux 3.6, destroying the attached session follows that session's detach-on-destroy policy and may end the stream."},"source":{"file":"tmux/notification_stream.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationStream","product":"core","slug":"tmux-notificationstream"},{"id":"tmux.NotificationOptions","name":"NotificationOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NotificationOptions configures which notifications a stream receives. The zero value retains notifications other than pane output."},"source":{"file":"tmux/notification_stream.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationOptions","product":"core","slug":"tmux-notificationoptions"},{"id":"tmux.NotificationOptions.IncludePaneOutput","name":"IncludePaneOutput","kind":"attribute","modifiers":[],"parent":"tmux.NotificationOptions","signatures":[],"type":"bool","doc":{"summary":"IncludePaneOutput includes output and extended-output notifications."},"source":{"file":"tmux/notification_stream.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationOptions.IncludePaneOutput","product":"core","slug":"tmux-notificationoptions-includepaneoutput"},{"id":"tmux.NotificationOptions.PauseAfter","name":"PauseAfter","kind":"attribute","modifiers":[],"parent":"tmux.NotificationOptions","signatures":[],"type":"time.Duration","doc":{"summary":"PauseAfter asks tmux to hold a pane's output once this stream is that far behind on it, and to say so with a pause notification. Zero leaves tmux's own behavior, which ends a stream that falls five minutes behind rather than pausing it. tmux resolves this to whole seconds, and it governs pane output, so it requires IncludePaneOutput."},"source":{"file":"tmux/notification_stream.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationOptions.PauseAfter","product":"core","slug":"tmux-notificationoptions-pauseafter"},{"id":"tmux.Server.OpenNotifications","name":"OpenNotifications","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"session","type":"Session"},{"name":"options","type":"NotificationOptions"}],"returns":"(*NotificationStream, error)"}],"doc":{"summary":"OpenNotifications starts an owned observation-only stream attached to session. Session must belong to the same configured server selector. A connection-bound server returns [ErrConnectionRequiresProcess]."},"source":{"file":"tmux/notification_stream.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.OpenNotifications","product":"core","slug":"tmux-server-opennotifications"},{"id":"tmux.NotificationStream.ContinuePane","name":"ContinuePane","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"pane","type":"PaneID"}],"returns":"error"}],"doc":{"summary":"ContinuePane resumes pane output tmux held after this stream fell behind on it. tmux does not replay what it held, so read the pane to recover that span rather than waiting for it. Resuming a pane tmux never paused does nothing and reports nothing, because tmux answers neither."},"source":{"file":"tmux/notification_stream.go","line":91,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationStream.ContinuePane","product":"core","slug":"tmux-notificationstream-continuepane"},{"id":"tmux.SubscriptionRequest","name":"SubscriptionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SubscriptionRequest names a format for tmux to evaluate and report on this stream whenever its value changes. Its zero value is invalid because Name and Format are required. At most one of Session, Window, and Pane scopes the evaluation; none evaluates against the stream's attached session.","body":"tmux stops evaluating a pane-scoped subscription once that pane's process has\nexited, so a subscription that must observe pane death is scoped to the\nwindow and reads the pane from the change it reports."},"source":{"file":"tmux/notification_stream.go","line":115,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionRequest","product":"core","slug":"tmux-subscriptionrequest"},{"id":"tmux.SubscriptionRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"string","doc":{"summary":"Name identifies the subscription in each change and to Unsubscribe. It may not contain a colon or a space."},"source":{"file":"tmux/notification_stream.go","line":118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionRequest.Name","product":"core","slug":"tmux-subscriptionrequest-name"},{"id":"tmux.SubscriptionRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"string","doc":{"summary":"Format is the tmux format to evaluate, such as #{pane_current_command}."},"source":{"file":"tmux/notification_stream.go","line":120,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionRequest.Format","product":"core","slug":"tmux-subscriptionrequest-format"},{"id":"tmux.SubscriptionRequest.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"SessionID","doc":{"summary":"Session scopes evaluation to the stream's attached session. tmux always evaluates a session-scoped subscription against the control client's own session, so this only requests that scope; it is not a selector, and any value is equivalent to the stream's own session."},"source":{"file":"tmux/notification_stream.go","line":125,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionRequest.Session","product":"core","slug":"tmux-subscriptionrequest-session"},{"id":"tmux.SubscriptionRequest.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"WindowID","doc":{"summary":"Window scopes evaluation to one window."},"source":{"file":"tmux/notification_stream.go","line":127,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionRequest.Window","product":"core","slug":"tmux-subscriptionrequest-window"},{"id":"tmux.SubscriptionRequest.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"PaneID","doc":{"summary":"Pane scopes evaluation to one pane."},"source":{"file":"tmux/notification_stream.go","line":129,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SubscriptionRequest.Pane","product":"core","slug":"tmux-subscriptionrequest-pane"},{"id":"tmux.NotificationStream.Subscribe","name":"Subscribe","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SubscriptionRequest"}],"returns":"error"}],"doc":{"summary":"Subscribe asks tmux to evaluate request's format and report it on this stream as a subscription-changed notification, read with [ControlNotification.Subscription]. tmux reports the value at its next evaluation, about a second later, and then each time it changes. Arming a name already armed replaces its format."},"source":{"file":"tmux/notification_stream.go","line":189,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationStream.Subscribe","product":"core","slug":"tmux-notificationstream-subscribe"},{"id":"tmux.NotificationStream.Unsubscribe","name":"Unsubscribe","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"Unsubscribe stops the subscription armed under name. Stopping a name that was never armed does nothing and reports nothing, because tmux answers neither."},"source":{"file":"tmux/notification_stream.go","line":204,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationStream.Unsubscribe","product":"core","slug":"tmux-notificationstream-unsubscribe"},{"id":"tmux.Session.OpenNotifications","name":"OpenNotifications","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"options","type":"NotificationOptions"}],"returns":"(*NotificationStream, error)"}],"doc":{"summary":"OpenNotifications starts an owned notification stream attached to the receiver. It does not change the receiver's transport or expose control commands. A connection-bound receiver returns [ErrConnectionRequiresProcess]."},"source":{"file":"tmux/notification_stream.go","line":233,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.OpenNotifications","product":"core","slug":"tmux-session-opennotifications"},{"id":"tmux.NotificationStream.Next","name":"Next","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ControlNotification, error)"}],"doc":{"summary":"Next returns the next ordered control-mode notification. Exactly one caller may use Next at a time."},"source":{"file":"tmux/notification_stream.go","line":242,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationStream.Next","product":"core","slug":"tmux-notificationstream-next"},{"id":"tmux.NotificationStream.Notifications","name":"Notifications","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"iter.Seq2[ControlNotification, error]"}],"doc":{"summary":"Notifications returns [NotificationStream.Next] as a range loop; exactly one iterator or direct read may run at a time. Malformed notifications yield their error and iteration continues; every other error ends the loop after being yielded."},"source":{"file":"tmux/notification_stream.go","line":255,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationStream.Notifications","product":"core","slug":"tmux-notificationstream-notifications"},{"id":"tmux.NotificationStream.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts idempotent stream shutdown and waits within ctx. The context bounds only the wait; a later call may resume waiting for shutdown."},"source":{"file":"tmux/notification_stream.go","line":263,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationStream.CloseContext","product":"core","slug":"tmux-notificationstream-closecontext"},{"id":"tmux.NotificationStream.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the notification stream. It is safe to call concurrently and more than once."},"source":{"file":"tmux/notification_stream.go","line":272,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NotificationStream.Close","product":"core","slug":"tmux-notificationstream-close"},{"id":"tmux.CommandTransport","name":"CommandTransport","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandTransport names how one tmux command reached tmux."},"source":{"file":"tmux/observer.go","line":9,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTransport","product":"core","slug":"tmux-commandtransport"},{"id":"tmux.CommandTransportProcess","name":"CommandTransportProcess","kind":"constant","modifiers":[],"signatures":[],"type":"CommandTransport","doc":{"summary":"CommandTransportProcess ran the command as its own tmux process."},"source":{"file":"tmux/observer.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTransportProcess","product":"core","slug":"tmux-commandtransportprocess"},{"id":"tmux.CommandTransportConnection","name":"CommandTransportConnection","kind":"constant","modifiers":[],"signatures":[],"type":"CommandTransport","doc":{"summary":"CommandTransportConnection carried the command over a control-mode connection opened earlier."},"source":{"file":"tmux/observer.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTransportConnection","product":"core","slug":"tmux-commandtransportconnection"},{"id":"tmux.CommandTransport.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.CommandTransport","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer."},"source":{"file":"tmux/observer.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTransport.String","product":"core","slug":"tmux-commandtransport-string"},{"id":"tmux.CommandTrace","name":"CommandTrace","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandTrace records one completed attempt to run a tmux command. It carries neither the argument vector nor tmux's output, both of which may hold passwords, tokens, or pane contents; [CommandError] is where a caller that accepts that reads them."},"source":{"file":"tmux/observer.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTrace","product":"core","slug":"tmux-commandtrace"},{"id":"tmux.CommandTrace.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"string","doc":{"summary":"Subcommand is the tmux subcommand, such as \"list-sessions\". A raw command list reports its first subcommand."},"source":{"file":"tmux/observer.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTrace.Subcommand","product":"core","slug":"tmux-commandtrace-subcommand"},{"id":"tmux.CommandTrace.Transport","name":"Transport","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"CommandTransport","doc":{"summary":"Transport names how the command reached tmux."},"source":{"file":"tmux/observer.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTrace.Transport","product":"core","slug":"tmux-commandtrace-transport"},{"id":"tmux.CommandTrace.Duration","name":"Duration","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"time.Duration","doc":{"summary":"Duration is how long the attempt took."},"source":{"file":"tmux/observer.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTrace.Duration","product":"core","slug":"tmux-commandtrace-duration"},{"id":"tmux.CommandTrace.ExitCode","name":"ExitCode","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"int","doc":{"summary":"ExitCode is tmux's exit code, or -1 when no tmux command ran."},"source":{"file":"tmux/observer.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTrace.ExitCode","product":"core","slug":"tmux-commandtrace-exitcode"},{"id":"tmux.CommandTrace.Err","name":"Err","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"error","doc":{"summary":"Err is the transport or validation failure, if any. A completed tmux command that failed leaves this nil and reports through ExitCode."},"source":{"file":"tmux/observer.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTrace.Err","product":"core","slug":"tmux-commandtrace-err"},{"id":"tmux.CommandTrace.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.CommandTrace","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer."},"source":{"file":"tmux/observer.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandTrace.String","product":"core","slug":"tmux-commandtrace-string"},{"id":"tmux.CommandObserver","name":"CommandObserver","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandObserver receives one [CommandTrace] per tmux command a [Server] and the values derived from it run:","body":"server, err := tmux.NewServer(tmux.ServerOptions{\n\tCommandObserver: func(trace tmux.CommandTrace) {\n\t\tslog.Info(\"tmux\", \"command\", trace.Subcommand,\n\t\t\t\"transport\", trace.Transport.String(),\n\t\t\t\"duration\", trace.Duration, \"exit\", trace.ExitCode)\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\n\nIt is called synchronously on the goroutine that ran the command, after the\ncommand finishes and before its result is returned, so a slow observer slows\nevery command. Operations may invoke it concurrently; synchronize shared\nstate. A nil observer costs nothing, not even the clock reads.\n\nIt sees the version probes this package runs on its own behalf, and the\nidentity probe a daemon guard runs to decide whether a failure was a\nreplaced daemon, so one call can produce more than one trace."},"source":{"file":"tmux/observer.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandObserver","product":"core","slug":"tmux-commandobserver"},{"id":"tmux.ErrMalformedOptionOutput","name":"ErrMalformedOptionOutput","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedOptionOutput identifies a recognized option or hook record that cannot be decoded without ambiguity. It is matched by errors.Is for OptionDecodeError."},"source":{"file":"tmux/option_decode.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrMalformedOptionOutput","product":"core","slug":"tmux-errmalformedoptionoutput"},{"id":"tmux.OptionDecodeError","name":"OptionDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionDecodeError reports a malformed recognized record without retaining its value. It matches [ErrMalformedOptionOutput] through errors.Is; callers can recover Record and Reason with errors.As. Record is the zero-based physical output line."},"source":{"file":"tmux/option_decode.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionDecodeError","product":"core","slug":"tmux-optiondecodeerror"},{"id":"tmux.OptionDecodeError.Record","name":"Record","kind":"attribute","modifiers":[],"parent":"tmux.OptionDecodeError","signatures":[],"type":"int","doc":{"summary":"Record is the zero-based physical output line."},"source":{"file":"tmux/option_decode.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionDecodeError.Record","product":"core","slug":"tmux-optiondecodeerror-record"},{"id":"tmux.OptionDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.OptionDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes the malformed record without retaining its value."},"source":{"file":"tmux/option_decode.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionDecodeError.Reason","product":"core","slug":"tmux-optiondecodeerror-reason"},{"id":"tmux.OptionDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.OptionDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/option_decode.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionDecodeError.Error","product":"core","slug":"tmux-optiondecodeerror-error"},{"id":"tmux.OptionDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.OptionDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes OptionDecodeError compatible with ErrMalformedOptionOutput."},"source":{"file":"tmux/option_decode.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionDecodeError.Unwrap","product":"core","slug":"tmux-optiondecodeerror-unwrap"},{"id":"tmux.ErrOption","name":"ErrOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrOption identifies a failed high-level option or hook operation. It is matched by errors.Is for OptionError."},"source":{"file":"tmux/option_error.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrOption","product":"core","slug":"tmux-erroption"},{"id":"tmux.ErrUnknownOption","name":"ErrUnknownOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrUnknownOption identifies tmux's case-sensitive unknown-option diagnostic."},"source":{"file":"tmux/option_error.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrUnknownOption","product":"core","slug":"tmux-errunknownoption"},{"id":"tmux.ErrInvalidOption","name":"ErrInvalidOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidOption identifies tmux's case-sensitive invalid-option diagnostic."},"source":{"file":"tmux/option_error.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidOption","product":"core","slug":"tmux-errinvalidoption"},{"id":"tmux.ErrInvalidOptionValue","name":"ErrInvalidOptionValue","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidOptionValue identifies a typed option value outside its active tmux-version domain."},"source":{"file":"tmux/option_error.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidOptionValue","product":"core","slug":"tmux-errinvalidoptionvalue"},{"id":"tmux.ErrAmbiguousOption","name":"ErrAmbiguousOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrAmbiguousOption identifies tmux's case-sensitive ambiguous-option diagnostic."},"source":{"file":"tmux/option_error.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrAmbiguousOption","product":"core","slug":"tmux-errambiguousoption"},{"id":"tmux.ErrOptionTarget","name":"ErrOptionTarget","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrOptionTarget identifies an option or hook operation whose target did not resolve, which is the failure an unknown name is most easily mistaken for. Classifying it discloses nothing that redaction protects: which kind of failure occurred is not one of the values or hook commands an option error withholds."},"source":{"file":"tmux/option_error.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrOptionTarget","product":"core","slug":"tmux-erroptiontarget"},{"id":"tmux.OptionValueError","name":"OptionValueError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionValueError reports a rejected typed option value without retaining or rendering that value. It matches [ErrInvalidOptionValue] and [ErrOption]."},"source":{"file":"tmux/option_error.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionValueError","product":"core","slug":"tmux-optionvalueerror"},{"id":"tmux.OptionValueError.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.OptionValueError","signatures":[],"type":"string","doc":{"summary":"Name is the safe, generated tmux option name."},"source":{"file":"tmux/option_error.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionValueError.Name","product":"core","slug":"tmux-optionvalueerror-name"},{"id":"tmux.OptionValueError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.OptionValueError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error without disclosing the attempted value."},"source":{"file":"tmux/option_error.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionValueError.Error","product":"core","slug":"tmux-optionvalueerror-error"},{"id":"tmux.OptionValueError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.OptionValueError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes OptionValueError compatible with ErrInvalidOptionValue."},"source":{"file":"tmux/option_error.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionValueError.Unwrap","product":"core","slug":"tmux-optionvalueerror-unwrap"},{"id":"tmux.OptionError","name":"OptionError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionError reports a completed high-level option or hook failure. It matches [ErrOption] and a specific option sentinel through errors.Is; callers can recover its fields with errors.As. Library-created errors retain only Result.ExitCode. Error never renders command output because option values and hook commands may be secret; callers may construct exported values with other contents."},"source":{"file":"tmux/option_error.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionError","product":"core","slug":"tmux-optionerror"},{"id":"tmux.OptionError.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.OptionError","signatures":[],"type":"string","doc":{"summary":"Subcommand is the failed tmux option or hook subcommand."},"source":{"file":"tmux/option_error.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionError.Subcommand","product":"core","slug":"tmux-optionerror-subcommand"},{"id":"tmux.OptionError.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.OptionError","signatures":[],"type":"string","doc":{"summary":"Name is the option or hook name, when available."},"source":{"file":"tmux/option_error.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionError.Name","product":"core","slug":"tmux-optionerror-name"},{"id":"tmux.OptionError.Result","name":"Result","kind":"attribute","modifiers":[],"parent":"tmux.OptionError","signatures":[],"type":"CommandResult","doc":{"summary":"Result contains the library-created error's exit code and no diagnostics."},"source":{"file":"tmux/option_error.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionError.Result","product":"core","slug":"tmux-optionerror-result"},{"id":"tmux.OptionError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.OptionError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/option_error.go","line":72,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionError.Error","product":"core","slug":"tmux-optionerror-error"},{"id":"tmux.OptionError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.OptionError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes OptionError compatible with ErrOption and its specific kinds."},"source":{"file":"tmux/option_error.go","line":102,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionError.Unwrap","product":"core","slug":"tmux-optionerror-unwrap"},{"id":"tmux.ActivityAction","name":"ActivityAction","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ActivityAction is a typed value for the \"activity-action\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":11,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ActivityAction","product":"core","slug":"tmux-activityaction"},{"id":"tmux.ActivityActionNone","name":"ActivityActionNone","kind":"constant","modifiers":[],"signatures":[],"type":"ActivityAction","doc":{"summary":"ActivityActionNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ActivityActionNone","product":"core","slug":"tmux-activityactionnone"},{"id":"tmux.ActivityActionAny","name":"ActivityActionAny","kind":"constant","modifiers":[],"signatures":[],"type":"ActivityAction","doc":{"summary":"ActivityActionAny selects \"any\"."},"source":{"file":"tmux/option_generated.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ActivityActionAny","product":"core","slug":"tmux-activityactionany"},{"id":"tmux.ActivityActionCurrent","name":"ActivityActionCurrent","kind":"constant","modifiers":[],"signatures":[],"type":"ActivityAction","doc":{"summary":"ActivityActionCurrent selects \"current\"."},"source":{"file":"tmux/option_generated.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ActivityActionCurrent","product":"core","slug":"tmux-activityactioncurrent"},{"id":"tmux.ActivityActionOther","name":"ActivityActionOther","kind":"constant","modifiers":[],"signatures":[],"type":"ActivityAction","doc":{"summary":"ActivityActionOther selects \"other\"."},"source":{"file":"tmux/option_generated.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ActivityActionOther","product":"core","slug":"tmux-activityactionother"},{"id":"tmux.ActivityAction.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ActivityAction","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ActivityAction.String","product":"core","slug":"tmux-activityaction-string"},{"id":"tmux.ActivityAction.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ActivityAction","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ActivityAction.Valid","product":"core","slug":"tmux-activityaction-valid"},{"id":"tmux.AllowPassthrough","name":"AllowPassthrough","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"AllowPassthrough is a typed value for the \"allow-passthrough\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AllowPassthrough","product":"core","slug":"tmux-allowpassthrough"},{"id":"tmux.AllowPassthroughOff","name":"AllowPassthroughOff","kind":"constant","modifiers":[],"signatures":[],"type":"AllowPassthrough","doc":{"summary":"AllowPassthroughOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AllowPassthroughOff","product":"core","slug":"tmux-allowpassthroughoff"},{"id":"tmux.AllowPassthroughOn","name":"AllowPassthroughOn","kind":"constant","modifiers":[],"signatures":[],"type":"AllowPassthrough","doc":{"summary":"AllowPassthroughOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AllowPassthroughOn","product":"core","slug":"tmux-allowpassthroughon"},{"id":"tmux.AllowPassthroughAll","name":"AllowPassthroughAll","kind":"constant","modifiers":[],"signatures":[],"type":"AllowPassthrough","doc":{"summary":"AllowPassthroughAll selects \"all\"."},"source":{"file":"tmux/option_generated.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AllowPassthroughAll","product":"core","slug":"tmux-allowpassthroughall"},{"id":"tmux.AllowPassthrough.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.AllowPassthrough","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AllowPassthrough.String","product":"core","slug":"tmux-allowpassthrough-string"},{"id":"tmux.AllowPassthrough.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.AllowPassthrough","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AllowPassthrough.Valid","product":"core","slug":"tmux-allowpassthrough-valid"},{"id":"tmux.BellAction","name":"BellAction","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"BellAction is a typed value for the \"bell-action\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BellAction","product":"core","slug":"tmux-bellaction"},{"id":"tmux.BellActionNone","name":"BellActionNone","kind":"constant","modifiers":[],"signatures":[],"type":"BellAction","doc":{"summary":"BellActionNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BellActionNone","product":"core","slug":"tmux-bellactionnone"},{"id":"tmux.BellActionAny","name":"BellActionAny","kind":"constant","modifiers":[],"signatures":[],"type":"BellAction","doc":{"summary":"BellActionAny selects \"any\"."},"source":{"file":"tmux/option_generated.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BellActionAny","product":"core","slug":"tmux-bellactionany"},{"id":"tmux.BellActionCurrent","name":"BellActionCurrent","kind":"constant","modifiers":[],"signatures":[],"type":"BellAction","doc":{"summary":"BellActionCurrent selects \"current\"."},"source":{"file":"tmux/option_generated.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BellActionCurrent","product":"core","slug":"tmux-bellactioncurrent"},{"id":"tmux.BellActionOther","name":"BellActionOther","kind":"constant","modifiers":[],"signatures":[],"type":"BellAction","doc":{"summary":"BellActionOther selects \"other\"."},"source":{"file":"tmux/option_generated.go","line":73,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BellActionOther","product":"core","slug":"tmux-bellactionother"},{"id":"tmux.BellAction.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.BellAction","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BellAction.String","product":"core","slug":"tmux-bellaction-string"},{"id":"tmux.BellAction.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.BellAction","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BellAction.Valid","product":"core","slug":"tmux-bellaction-valid"},{"id":"tmux.ClockModeStyle","name":"ClockModeStyle","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClockModeStyle is a typed value for the \"clock-mode-style\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClockModeStyle","product":"core","slug":"tmux-clockmodestyle"},{"id":"tmux.ClockModeStyle12","name":"ClockModeStyle12","kind":"constant","modifiers":[],"signatures":[],"type":"ClockModeStyle","doc":{"summary":"ClockModeStyle12 selects \"12\"."},"source":{"file":"tmux/option_generated.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClockModeStyle12","product":"core","slug":"tmux-clockmodestyle12"},{"id":"tmux.ClockModeStyle24","name":"ClockModeStyle24","kind":"constant","modifiers":[],"signatures":[],"type":"ClockModeStyle","doc":{"summary":"ClockModeStyle24 selects \"24\"."},"source":{"file":"tmux/option_generated.go","line":96,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClockModeStyle24","product":"core","slug":"tmux-clockmodestyle24"},{"id":"tmux.ClockModeStyle12WithSeconds","name":"ClockModeStyle12WithSeconds","kind":"constant","modifiers":[],"signatures":[],"type":"ClockModeStyle","doc":{"summary":"ClockModeStyle12WithSeconds selects \"12-with-seconds\"."},"source":{"file":"tmux/option_generated.go","line":98,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClockModeStyle12WithSeconds","product":"core","slug":"tmux-clockmodestyle12withseconds"},{"id":"tmux.ClockModeStyle24WithSeconds","name":"ClockModeStyle24WithSeconds","kind":"constant","modifiers":[],"signatures":[],"type":"ClockModeStyle","doc":{"summary":"ClockModeStyle24WithSeconds selects \"24-with-seconds\"."},"source":{"file":"tmux/option_generated.go","line":100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClockModeStyle24WithSeconds","product":"core","slug":"tmux-clockmodestyle24withseconds"},{"id":"tmux.ClockModeStyle.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ClockModeStyle","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":104,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClockModeStyle.String","product":"core","slug":"tmux-clockmodestyle-string"},{"id":"tmux.ClockModeStyle.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ClockModeStyle","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":107,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClockModeStyle.Valid","product":"core","slug":"tmux-clockmodestyle-valid"},{"id":"tmux.CopyModeLineNumbers","name":"CopyModeLineNumbers","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CopyModeLineNumbers is a typed value for the \"copy-mode-line-numbers\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":117,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeLineNumbers","product":"core","slug":"tmux-copymodelinenumbers"},{"id":"tmux.CopyModeLineNumbersOff","name":"CopyModeLineNumbersOff","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":121,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeLineNumbersOff","product":"core","slug":"tmux-copymodelinenumbersoff"},{"id":"tmux.CopyModeLineNumbersDefault","name":"CopyModeLineNumbersDefault","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersDefault selects \"default\"."},"source":{"file":"tmux/option_generated.go","line":123,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeLineNumbersDefault","product":"core","slug":"tmux-copymodelinenumbersdefault"},{"id":"tmux.CopyModeLineNumbersAbsolute","name":"CopyModeLineNumbersAbsolute","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersAbsolute selects \"absolute\"."},"source":{"file":"tmux/option_generated.go","line":125,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeLineNumbersAbsolute","product":"core","slug":"tmux-copymodelinenumbersabsolute"},{"id":"tmux.CopyModeLineNumbersRelative","name":"CopyModeLineNumbersRelative","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersRelative selects \"relative\"."},"source":{"file":"tmux/option_generated.go","line":127,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeLineNumbersRelative","product":"core","slug":"tmux-copymodelinenumbersrelative"},{"id":"tmux.CopyModeLineNumbersHybrid","name":"CopyModeLineNumbersHybrid","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersHybrid selects \"hybrid\"."},"source":{"file":"tmux/option_generated.go","line":129,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeLineNumbersHybrid","product":"core","slug":"tmux-copymodelinenumbershybrid"},{"id":"tmux.CopyModeLineNumbers.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.CopyModeLineNumbers","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":133,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeLineNumbers.String","product":"core","slug":"tmux-copymodelinenumbers-string"},{"id":"tmux.CopyModeLineNumbers.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.CopyModeLineNumbers","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":136,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeLineNumbers.Valid","product":"core","slug":"tmux-copymodelinenumbers-valid"},{"id":"tmux.CursorStyle","name":"CursorStyle","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CursorStyle is a typed value for the \"cursor-style\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":146,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyle","product":"core","slug":"tmux-cursorstyle"},{"id":"tmux.CursorStyleDefault","name":"CursorStyleDefault","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleDefault selects \"default\"."},"source":{"file":"tmux/option_generated.go","line":150,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyleDefault","product":"core","slug":"tmux-cursorstyledefault"},{"id":"tmux.CursorStyleBlinkingBlock","name":"CursorStyleBlinkingBlock","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBlinkingBlock selects \"blinking-block\"."},"source":{"file":"tmux/option_generated.go","line":152,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyleBlinkingBlock","product":"core","slug":"tmux-cursorstyleblinkingblock"},{"id":"tmux.CursorStyleBlock","name":"CursorStyleBlock","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBlock selects \"block\"."},"source":{"file":"tmux/option_generated.go","line":154,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyleBlock","product":"core","slug":"tmux-cursorstyleblock"},{"id":"tmux.CursorStyleBlinkingUnderline","name":"CursorStyleBlinkingUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBlinkingUnderline selects \"blinking-underline\"."},"source":{"file":"tmux/option_generated.go","line":156,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyleBlinkingUnderline","product":"core","slug":"tmux-cursorstyleblinkingunderline"},{"id":"tmux.CursorStyleUnderline","name":"CursorStyleUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleUnderline selects \"underline\"."},"source":{"file":"tmux/option_generated.go","line":158,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyleUnderline","product":"core","slug":"tmux-cursorstyleunderline"},{"id":"tmux.CursorStyleBlinkingBar","name":"CursorStyleBlinkingBar","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBlinkingBar selects \"blinking-bar\"."},"source":{"file":"tmux/option_generated.go","line":160,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyleBlinkingBar","product":"core","slug":"tmux-cursorstyleblinkingbar"},{"id":"tmux.CursorStyleBar","name":"CursorStyleBar","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBar selects \"bar\"."},"source":{"file":"tmux/option_generated.go","line":162,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyleBar","product":"core","slug":"tmux-cursorstylebar"},{"id":"tmux.CursorStyle.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.CursorStyle","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":166,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyle.String","product":"core","slug":"tmux-cursorstyle-string"},{"id":"tmux.CursorStyle.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.CursorStyle","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":169,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CursorStyle.Valid","product":"core","slug":"tmux-cursorstyle-valid"},{"id":"tmux.DestroyUnattached","name":"DestroyUnattached","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DestroyUnattached is a typed value for the \"destroy-unattached\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":179,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DestroyUnattached","product":"core","slug":"tmux-destroyunattached"},{"id":"tmux.DestroyUnattachedOff","name":"DestroyUnattachedOff","kind":"constant","modifiers":[],"signatures":[],"type":"DestroyUnattached","doc":{"summary":"DestroyUnattachedOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":183,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DestroyUnattachedOff","product":"core","slug":"tmux-destroyunattachedoff"},{"id":"tmux.DestroyUnattachedOn","name":"DestroyUnattachedOn","kind":"constant","modifiers":[],"signatures":[],"type":"DestroyUnattached","doc":{"summary":"DestroyUnattachedOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":185,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DestroyUnattachedOn","product":"core","slug":"tmux-destroyunattachedon"},{"id":"tmux.DestroyUnattachedKeepLast","name":"DestroyUnattachedKeepLast","kind":"constant","modifiers":[],"signatures":[],"type":"DestroyUnattached","doc":{"summary":"DestroyUnattachedKeepLast selects \"keep-last\"."},"source":{"file":"tmux/option_generated.go","line":187,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DestroyUnattachedKeepLast","product":"core","slug":"tmux-destroyunattachedkeeplast"},{"id":"tmux.DestroyUnattachedKeepGroup","name":"DestroyUnattachedKeepGroup","kind":"constant","modifiers":[],"signatures":[],"type":"DestroyUnattached","doc":{"summary":"DestroyUnattachedKeepGroup selects \"keep-group\"."},"source":{"file":"tmux/option_generated.go","line":189,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DestroyUnattachedKeepGroup","product":"core","slug":"tmux-destroyunattachedkeepgroup"},{"id":"tmux.DestroyUnattached.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.DestroyUnattached","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":193,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DestroyUnattached.String","product":"core","slug":"tmux-destroyunattached-string"},{"id":"tmux.DestroyUnattached.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.DestroyUnattached","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":196,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DestroyUnattached.Valid","product":"core","slug":"tmux-destroyunattached-valid"},{"id":"tmux.DetachOnDestroy","name":"DetachOnDestroy","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DetachOnDestroy is a typed value for the \"detach-on-destroy\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":206,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachOnDestroy","product":"core","slug":"tmux-detachondestroy"},{"id":"tmux.DetachOnDestroyOff","name":"DetachOnDestroyOff","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":210,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachOnDestroyOff","product":"core","slug":"tmux-detachondestroyoff"},{"id":"tmux.DetachOnDestroyOn","name":"DetachOnDestroyOn","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":212,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachOnDestroyOn","product":"core","slug":"tmux-detachondestroyon"},{"id":"tmux.DetachOnDestroyNoDetached","name":"DetachOnDestroyNoDetached","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyNoDetached selects \"no-detached\"."},"source":{"file":"tmux/option_generated.go","line":214,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachOnDestroyNoDetached","product":"core","slug":"tmux-detachondestroynodetached"},{"id":"tmux.DetachOnDestroyPrevious","name":"DetachOnDestroyPrevious","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyPrevious selects \"previous\"."},"source":{"file":"tmux/option_generated.go","line":216,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachOnDestroyPrevious","product":"core","slug":"tmux-detachondestroyprevious"},{"id":"tmux.DetachOnDestroyNext","name":"DetachOnDestroyNext","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyNext selects \"next\"."},"source":{"file":"tmux/option_generated.go","line":218,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachOnDestroyNext","product":"core","slug":"tmux-detachondestroynext"},{"id":"tmux.DetachOnDestroy.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.DetachOnDestroy","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":222,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachOnDestroy.String","product":"core","slug":"tmux-detachondestroy-string"},{"id":"tmux.DetachOnDestroy.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.DetachOnDestroy","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":225,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachOnDestroy.Valid","product":"core","slug":"tmux-detachondestroy-valid"},{"id":"tmux.ExtendedKeys","name":"ExtendedKeys","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ExtendedKeys is a typed value for the \"extended-keys\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":235,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeys","product":"core","slug":"tmux-extendedkeys"},{"id":"tmux.ExtendedKeysOff","name":"ExtendedKeysOff","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeys","doc":{"summary":"ExtendedKeysOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":239,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeysOff","product":"core","slug":"tmux-extendedkeysoff"},{"id":"tmux.ExtendedKeysOn","name":"ExtendedKeysOn","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeys","doc":{"summary":"ExtendedKeysOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":241,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeysOn","product":"core","slug":"tmux-extendedkeyson"},{"id":"tmux.ExtendedKeysAlways","name":"ExtendedKeysAlways","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeys","doc":{"summary":"ExtendedKeysAlways selects \"always\"."},"source":{"file":"tmux/option_generated.go","line":243,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeysAlways","product":"core","slug":"tmux-extendedkeysalways"},{"id":"tmux.ExtendedKeys.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ExtendedKeys","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":247,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeys.String","product":"core","slug":"tmux-extendedkeys-string"},{"id":"tmux.ExtendedKeys.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ExtendedKeys","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":250,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeys.Valid","product":"core","slug":"tmux-extendedkeys-valid"},{"id":"tmux.ExtendedKeysFormat","name":"ExtendedKeysFormat","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ExtendedKeysFormat is a typed value for the \"extended-keys-format\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":260,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeysFormat","product":"core","slug":"tmux-extendedkeysformat"},{"id":"tmux.ExtendedKeysFormatCSIU","name":"ExtendedKeysFormatCSIU","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeysFormat","doc":{"summary":"ExtendedKeysFormatCSIU selects \"csi-u\"."},"source":{"file":"tmux/option_generated.go","line":264,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeysFormatCSIU","product":"core","slug":"tmux-extendedkeysformatcsiu"},{"id":"tmux.ExtendedKeysFormatXTerm","name":"ExtendedKeysFormatXTerm","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeysFormat","doc":{"summary":"ExtendedKeysFormatXTerm selects \"xterm\"."},"source":{"file":"tmux/option_generated.go","line":266,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeysFormatXTerm","product":"core","slug":"tmux-extendedkeysformatxterm"},{"id":"tmux.ExtendedKeysFormat.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ExtendedKeysFormat","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":270,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeysFormat.String","product":"core","slug":"tmux-extendedkeysformat-string"},{"id":"tmux.ExtendedKeysFormat.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ExtendedKeysFormat","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":273,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ExtendedKeysFormat.Valid","product":"core","slug":"tmux-extendedkeysformat-valid"},{"id":"tmux.GetClipboard","name":"GetClipboard","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"GetClipboard is a typed value for the \"get-clipboard\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":283,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GetClipboard","product":"core","slug":"tmux-getclipboard"},{"id":"tmux.GetClipboardOff","name":"GetClipboardOff","kind":"constant","modifiers":[],"signatures":[],"type":"GetClipboard","doc":{"summary":"GetClipboardOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":287,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GetClipboardOff","product":"core","slug":"tmux-getclipboardoff"},{"id":"tmux.GetClipboardBuffer","name":"GetClipboardBuffer","kind":"constant","modifiers":[],"signatures":[],"type":"GetClipboard","doc":{"summary":"GetClipboardBuffer selects \"buffer\"."},"source":{"file":"tmux/option_generated.go","line":289,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GetClipboardBuffer","product":"core","slug":"tmux-getclipboardbuffer"},{"id":"tmux.GetClipboardRequest","name":"GetClipboardRequest","kind":"constant","modifiers":[],"signatures":[],"type":"GetClipboard","doc":{"summary":"GetClipboardRequest selects \"request\"."},"source":{"file":"tmux/option_generated.go","line":291,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GetClipboardRequest","product":"core","slug":"tmux-getclipboardrequest"},{"id":"tmux.GetClipboardBoth","name":"GetClipboardBoth","kind":"constant","modifiers":[],"signatures":[],"type":"GetClipboard","doc":{"summary":"GetClipboardBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":293,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GetClipboardBoth","product":"core","slug":"tmux-getclipboardboth"},{"id":"tmux.GetClipboard.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.GetClipboard","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":297,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GetClipboard.String","product":"core","slug":"tmux-getclipboard-string"},{"id":"tmux.GetClipboard.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.GetClipboard","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":300,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GetClipboard.Valid","product":"core","slug":"tmux-getclipboard-valid"},{"id":"tmux.MenuBorderLines","name":"MenuBorderLines","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MenuBorderLines is a typed value for the \"menu-border-lines\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":310,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLines","product":"core","slug":"tmux-menuborderlines"},{"id":"tmux.MenuBorderLinesSingle","name":"MenuBorderLinesSingle","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesSingle selects \"single\"."},"source":{"file":"tmux/option_generated.go","line":314,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLinesSingle","product":"core","slug":"tmux-menuborderlinessingle"},{"id":"tmux.MenuBorderLinesDouble","name":"MenuBorderLinesDouble","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesDouble selects \"double\"."},"source":{"file":"tmux/option_generated.go","line":316,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLinesDouble","product":"core","slug":"tmux-menuborderlinesdouble"},{"id":"tmux.MenuBorderLinesHeavy","name":"MenuBorderLinesHeavy","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesHeavy selects \"heavy\"."},"source":{"file":"tmux/option_generated.go","line":318,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLinesHeavy","product":"core","slug":"tmux-menuborderlinesheavy"},{"id":"tmux.MenuBorderLinesSimple","name":"MenuBorderLinesSimple","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesSimple selects \"simple\"."},"source":{"file":"tmux/option_generated.go","line":320,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLinesSimple","product":"core","slug":"tmux-menuborderlinessimple"},{"id":"tmux.MenuBorderLinesRounded","name":"MenuBorderLinesRounded","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesRounded selects \"rounded\"."},"source":{"file":"tmux/option_generated.go","line":322,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLinesRounded","product":"core","slug":"tmux-menuborderlinesrounded"},{"id":"tmux.MenuBorderLinesPadded","name":"MenuBorderLinesPadded","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesPadded selects \"padded\"."},"source":{"file":"tmux/option_generated.go","line":324,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLinesPadded","product":"core","slug":"tmux-menuborderlinespadded"},{"id":"tmux.MenuBorderLinesNone","name":"MenuBorderLinesNone","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":326,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLinesNone","product":"core","slug":"tmux-menuborderlinesnone"},{"id":"tmux.MenuBorderLines.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.MenuBorderLines","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":330,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLines.String","product":"core","slug":"tmux-menuborderlines-string"},{"id":"tmux.MenuBorderLines.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.MenuBorderLines","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":333,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuBorderLines.Valid","product":"core","slug":"tmux-menuborderlines-valid"},{"id":"tmux.MessageLine","name":"MessageLine","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MessageLine is a typed value for the \"message-line\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":343,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MessageLine","product":"core","slug":"tmux-messageline"},{"id":"tmux.MessageLine0","name":"MessageLine0","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine0 selects \"0\"."},"source":{"file":"tmux/option_generated.go","line":347,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MessageLine0","product":"core","slug":"tmux-messageline0"},{"id":"tmux.MessageLine1","name":"MessageLine1","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine1 selects \"1\"."},"source":{"file":"tmux/option_generated.go","line":349,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MessageLine1","product":"core","slug":"tmux-messageline1"},{"id":"tmux.MessageLine2","name":"MessageLine2","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine2 selects \"2\"."},"source":{"file":"tmux/option_generated.go","line":351,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MessageLine2","product":"core","slug":"tmux-messageline2"},{"id":"tmux.MessageLine3","name":"MessageLine3","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine3 selects \"3\"."},"source":{"file":"tmux/option_generated.go","line":353,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MessageLine3","product":"core","slug":"tmux-messageline3"},{"id":"tmux.MessageLine4","name":"MessageLine4","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine4 selects \"4\"."},"source":{"file":"tmux/option_generated.go","line":355,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MessageLine4","product":"core","slug":"tmux-messageline4"},{"id":"tmux.MessageLine.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.MessageLine","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":359,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MessageLine.String","product":"core","slug":"tmux-messageline-string"},{"id":"tmux.MessageLine.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.MessageLine","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":362,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MessageLine.Valid","product":"core","slug":"tmux-messageline-valid"},{"id":"tmux.ModeKeys","name":"ModeKeys","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ModeKeys is a typed value for the \"mode-keys\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":372,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ModeKeys","product":"core","slug":"tmux-modekeys"},{"id":"tmux.ModeKeysEmacs","name":"ModeKeysEmacs","kind":"constant","modifiers":[],"signatures":[],"type":"ModeKeys","doc":{"summary":"ModeKeysEmacs selects \"emacs\"."},"source":{"file":"tmux/option_generated.go","line":376,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ModeKeysEmacs","product":"core","slug":"tmux-modekeysemacs"},{"id":"tmux.ModeKeysVi","name":"ModeKeysVi","kind":"constant","modifiers":[],"signatures":[],"type":"ModeKeys","doc":{"summary":"ModeKeysVi selects \"vi\"."},"source":{"file":"tmux/option_generated.go","line":378,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ModeKeysVi","product":"core","slug":"tmux-modekeysvi"},{"id":"tmux.ModeKeys.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ModeKeys","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":382,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ModeKeys.String","product":"core","slug":"tmux-modekeys-string"},{"id":"tmux.ModeKeys.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ModeKeys","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":385,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ModeKeys.Valid","product":"core","slug":"tmux-modekeys-valid"},{"id":"tmux.PaneBorderIndicators","name":"PaneBorderIndicators","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneBorderIndicators is a typed value for the \"pane-border-indicators\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":395,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderIndicators","product":"core","slug":"tmux-paneborderindicators"},{"id":"tmux.PaneBorderIndicatorsOff","name":"PaneBorderIndicatorsOff","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderIndicators","doc":{"summary":"PaneBorderIndicatorsOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":399,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderIndicatorsOff","product":"core","slug":"tmux-paneborderindicatorsoff"},{"id":"tmux.PaneBorderIndicatorsColour","name":"PaneBorderIndicatorsColour","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderIndicators","doc":{"summary":"PaneBorderIndicatorsColour selects \"colour\"."},"source":{"file":"tmux/option_generated.go","line":401,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderIndicatorsColour","product":"core","slug":"tmux-paneborderindicatorscolour"},{"id":"tmux.PaneBorderIndicatorsArrows","name":"PaneBorderIndicatorsArrows","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderIndicators","doc":{"summary":"PaneBorderIndicatorsArrows selects \"arrows\"."},"source":{"file":"tmux/option_generated.go","line":403,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderIndicatorsArrows","product":"core","slug":"tmux-paneborderindicatorsarrows"},{"id":"tmux.PaneBorderIndicatorsBoth","name":"PaneBorderIndicatorsBoth","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderIndicators","doc":{"summary":"PaneBorderIndicatorsBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":405,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderIndicatorsBoth","product":"core","slug":"tmux-paneborderindicatorsboth"},{"id":"tmux.PaneBorderIndicators.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneBorderIndicators","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":409,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderIndicators.String","product":"core","slug":"tmux-paneborderindicators-string"},{"id":"tmux.PaneBorderIndicators.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneBorderIndicators","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":412,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderIndicators.Valid","product":"core","slug":"tmux-paneborderindicators-valid"},{"id":"tmux.PaneBorderLines","name":"PaneBorderLines","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneBorderLines is a typed value for the \"pane-border-lines\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":422,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLines","product":"core","slug":"tmux-paneborderlines"},{"id":"tmux.PaneBorderLinesSingle","name":"PaneBorderLinesSingle","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesSingle selects \"single\"."},"source":{"file":"tmux/option_generated.go","line":426,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLinesSingle","product":"core","slug":"tmux-paneborderlinessingle"},{"id":"tmux.PaneBorderLinesDouble","name":"PaneBorderLinesDouble","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesDouble selects \"double\"."},"source":{"file":"tmux/option_generated.go","line":428,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLinesDouble","product":"core","slug":"tmux-paneborderlinesdouble"},{"id":"tmux.PaneBorderLinesHeavy","name":"PaneBorderLinesHeavy","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesHeavy selects \"heavy\"."},"source":{"file":"tmux/option_generated.go","line":430,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLinesHeavy","product":"core","slug":"tmux-paneborderlinesheavy"},{"id":"tmux.PaneBorderLinesSimple","name":"PaneBorderLinesSimple","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesSimple selects \"simple\"."},"source":{"file":"tmux/option_generated.go","line":432,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLinesSimple","product":"core","slug":"tmux-paneborderlinessimple"},{"id":"tmux.PaneBorderLinesNumber","name":"PaneBorderLinesNumber","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesNumber selects \"number\"."},"source":{"file":"tmux/option_generated.go","line":434,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLinesNumber","product":"core","slug":"tmux-paneborderlinesnumber"},{"id":"tmux.PaneBorderLinesSpaces","name":"PaneBorderLinesSpaces","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesSpaces selects \"spaces\"."},"source":{"file":"tmux/option_generated.go","line":436,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLinesSpaces","product":"core","slug":"tmux-paneborderlinesspaces"},{"id":"tmux.PaneBorderLines.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneBorderLines","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":440,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLines.String","product":"core","slug":"tmux-paneborderlines-string"},{"id":"tmux.PaneBorderLines.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneBorderLines","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":443,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderLines.Valid","product":"core","slug":"tmux-paneborderlines-valid"},{"id":"tmux.PaneBorderStatus","name":"PaneBorderStatus","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneBorderStatus is a typed value for the \"pane-border-status\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":453,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderStatus","product":"core","slug":"tmux-paneborderstatus"},{"id":"tmux.PaneBorderStatusOff","name":"PaneBorderStatusOff","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderStatus","doc":{"summary":"PaneBorderStatusOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":457,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderStatusOff","product":"core","slug":"tmux-paneborderstatusoff"},{"id":"tmux.PaneBorderStatusTop","name":"PaneBorderStatusTop","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderStatus","doc":{"summary":"PaneBorderStatusTop selects \"top\"."},"source":{"file":"tmux/option_generated.go","line":459,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderStatusTop","product":"core","slug":"tmux-paneborderstatustop"},{"id":"tmux.PaneBorderStatusBottom","name":"PaneBorderStatusBottom","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderStatus","doc":{"summary":"PaneBorderStatusBottom selects \"bottom\"."},"source":{"file":"tmux/option_generated.go","line":461,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderStatusBottom","product":"core","slug":"tmux-paneborderstatusbottom"},{"id":"tmux.PaneBorderStatus.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneBorderStatus","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":465,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderStatus.String","product":"core","slug":"tmux-paneborderstatus-string"},{"id":"tmux.PaneBorderStatus.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneBorderStatus","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":468,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneBorderStatus.Valid","product":"core","slug":"tmux-paneborderstatus-valid"},{"id":"tmux.PaneScrollbars","name":"PaneScrollbars","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneScrollbars is a typed value for the \"pane-scrollbars\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":478,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbars","product":"core","slug":"tmux-panescrollbars"},{"id":"tmux.PaneScrollbarsOff","name":"PaneScrollbarsOff","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbars","doc":{"summary":"PaneScrollbarsOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":482,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbarsOff","product":"core","slug":"tmux-panescrollbarsoff"},{"id":"tmux.PaneScrollbarsModal","name":"PaneScrollbarsModal","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbars","doc":{"summary":"PaneScrollbarsModal selects \"modal\"."},"source":{"file":"tmux/option_generated.go","line":484,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbarsModal","product":"core","slug":"tmux-panescrollbarsmodal"},{"id":"tmux.PaneScrollbarsOn","name":"PaneScrollbarsOn","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbars","doc":{"summary":"PaneScrollbarsOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":486,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbarsOn","product":"core","slug":"tmux-panescrollbarson"},{"id":"tmux.PaneScrollbars.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneScrollbars","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":490,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbars.String","product":"core","slug":"tmux-panescrollbars-string"},{"id":"tmux.PaneScrollbars.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneScrollbars","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":493,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbars.Valid","product":"core","slug":"tmux-panescrollbars-valid"},{"id":"tmux.PaneScrollbarsPosition","name":"PaneScrollbarsPosition","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneScrollbarsPosition is a typed value for the \"pane-scrollbars-position\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":503,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbarsPosition","product":"core","slug":"tmux-panescrollbarsposition"},{"id":"tmux.PaneScrollbarsPositionRight","name":"PaneScrollbarsPositionRight","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbarsPosition","doc":{"summary":"PaneScrollbarsPositionRight selects \"right\"."},"source":{"file":"tmux/option_generated.go","line":507,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbarsPositionRight","product":"core","slug":"tmux-panescrollbarspositionright"},{"id":"tmux.PaneScrollbarsPositionLeft","name":"PaneScrollbarsPositionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbarsPosition","doc":{"summary":"PaneScrollbarsPositionLeft selects \"left\"."},"source":{"file":"tmux/option_generated.go","line":509,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbarsPositionLeft","product":"core","slug":"tmux-panescrollbarspositionleft"},{"id":"tmux.PaneScrollbarsPosition.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneScrollbarsPosition","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":513,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbarsPosition.String","product":"core","slug":"tmux-panescrollbarsposition-string"},{"id":"tmux.PaneScrollbarsPosition.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneScrollbarsPosition","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":516,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneScrollbarsPosition.Valid","product":"core","slug":"tmux-panescrollbarsposition-valid"},{"id":"tmux.PopupBorderLines","name":"PopupBorderLines","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PopupBorderLines is a typed value for the \"popup-border-lines\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":526,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLines","product":"core","slug":"tmux-popupborderlines"},{"id":"tmux.PopupBorderLinesSingle","name":"PopupBorderLinesSingle","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesSingle selects \"single\"."},"source":{"file":"tmux/option_generated.go","line":530,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLinesSingle","product":"core","slug":"tmux-popupborderlinessingle"},{"id":"tmux.PopupBorderLinesDouble","name":"PopupBorderLinesDouble","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesDouble selects \"double\"."},"source":{"file":"tmux/option_generated.go","line":532,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLinesDouble","product":"core","slug":"tmux-popupborderlinesdouble"},{"id":"tmux.PopupBorderLinesHeavy","name":"PopupBorderLinesHeavy","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesHeavy selects \"heavy\"."},"source":{"file":"tmux/option_generated.go","line":534,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLinesHeavy","product":"core","slug":"tmux-popupborderlinesheavy"},{"id":"tmux.PopupBorderLinesSimple","name":"PopupBorderLinesSimple","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesSimple selects \"simple\"."},"source":{"file":"tmux/option_generated.go","line":536,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLinesSimple","product":"core","slug":"tmux-popupborderlinessimple"},{"id":"tmux.PopupBorderLinesRounded","name":"PopupBorderLinesRounded","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesRounded selects \"rounded\"."},"source":{"file":"tmux/option_generated.go","line":538,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLinesRounded","product":"core","slug":"tmux-popupborderlinesrounded"},{"id":"tmux.PopupBorderLinesPadded","name":"PopupBorderLinesPadded","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesPadded selects \"padded\"."},"source":{"file":"tmux/option_generated.go","line":540,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLinesPadded","product":"core","slug":"tmux-popupborderlinespadded"},{"id":"tmux.PopupBorderLinesNone","name":"PopupBorderLinesNone","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":542,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLinesNone","product":"core","slug":"tmux-popupborderlinesnone"},{"id":"tmux.PopupBorderLines.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PopupBorderLines","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":546,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLines.String","product":"core","slug":"tmux-popupborderlines-string"},{"id":"tmux.PopupBorderLines.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PopupBorderLines","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":549,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PopupBorderLines.Valid","product":"core","slug":"tmux-popupborderlines-valid"},{"id":"tmux.PromptCommandCursorStyle","name":"PromptCommandCursorStyle","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PromptCommandCursorStyle is a typed value for the \"prompt-command-cursor-style\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":559,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyle","product":"core","slug":"tmux-promptcommandcursorstyle"},{"id":"tmux.PromptCommandCursorStyleDefault","name":"PromptCommandCursorStyleDefault","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleDefault selects \"default\"."},"source":{"file":"tmux/option_generated.go","line":563,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyleDefault","product":"core","slug":"tmux-promptcommandcursorstyledefault"},{"id":"tmux.PromptCommandCursorStyleBlinkingBlock","name":"PromptCommandCursorStyleBlinkingBlock","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBlinkingBlock selects \"blinking-block\"."},"source":{"file":"tmux/option_generated.go","line":565,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyleBlinkingBlock","product":"core","slug":"tmux-promptcommandcursorstyleblinkingblock"},{"id":"tmux.PromptCommandCursorStyleBlock","name":"PromptCommandCursorStyleBlock","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBlock selects \"block\"."},"source":{"file":"tmux/option_generated.go","line":567,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyleBlock","product":"core","slug":"tmux-promptcommandcursorstyleblock"},{"id":"tmux.PromptCommandCursorStyleBlinkingUnderline","name":"PromptCommandCursorStyleBlinkingUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBlinkingUnderline selects \"blinking-underline\"."},"source":{"file":"tmux/option_generated.go","line":569,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyleBlinkingUnderline","product":"core","slug":"tmux-promptcommandcursorstyleblinkingunderline"},{"id":"tmux.PromptCommandCursorStyleUnderline","name":"PromptCommandCursorStyleUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleUnderline selects \"underline\"."},"source":{"file":"tmux/option_generated.go","line":571,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyleUnderline","product":"core","slug":"tmux-promptcommandcursorstyleunderline"},{"id":"tmux.PromptCommandCursorStyleBlinkingBar","name":"PromptCommandCursorStyleBlinkingBar","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBlinkingBar selects \"blinking-bar\"."},"source":{"file":"tmux/option_generated.go","line":573,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyleBlinkingBar","product":"core","slug":"tmux-promptcommandcursorstyleblinkingbar"},{"id":"tmux.PromptCommandCursorStyleBar","name":"PromptCommandCursorStyleBar","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBar selects \"bar\"."},"source":{"file":"tmux/option_generated.go","line":575,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyleBar","product":"core","slug":"tmux-promptcommandcursorstylebar"},{"id":"tmux.PromptCommandCursorStyle.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PromptCommandCursorStyle","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":579,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyle.String","product":"core","slug":"tmux-promptcommandcursorstyle-string"},{"id":"tmux.PromptCommandCursorStyle.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PromptCommandCursorStyle","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":582,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCommandCursorStyle.Valid","product":"core","slug":"tmux-promptcommandcursorstyle-valid"},{"id":"tmux.PromptCursorStyle","name":"PromptCursorStyle","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PromptCursorStyle is a typed value for the \"prompt-cursor-style\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":592,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyle","product":"core","slug":"tmux-promptcursorstyle"},{"id":"tmux.PromptCursorStyleDefault","name":"PromptCursorStyleDefault","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleDefault selects \"default\"."},"source":{"file":"tmux/option_generated.go","line":596,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyleDefault","product":"core","slug":"tmux-promptcursorstyledefault"},{"id":"tmux.PromptCursorStyleBlinkingBlock","name":"PromptCursorStyleBlinkingBlock","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBlinkingBlock selects \"blinking-block\"."},"source":{"file":"tmux/option_generated.go","line":598,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyleBlinkingBlock","product":"core","slug":"tmux-promptcursorstyleblinkingblock"},{"id":"tmux.PromptCursorStyleBlock","name":"PromptCursorStyleBlock","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBlock selects \"block\"."},"source":{"file":"tmux/option_generated.go","line":600,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyleBlock","product":"core","slug":"tmux-promptcursorstyleblock"},{"id":"tmux.PromptCursorStyleBlinkingUnderline","name":"PromptCursorStyleBlinkingUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBlinkingUnderline selects \"blinking-underline\"."},"source":{"file":"tmux/option_generated.go","line":602,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyleBlinkingUnderline","product":"core","slug":"tmux-promptcursorstyleblinkingunderline"},{"id":"tmux.PromptCursorStyleUnderline","name":"PromptCursorStyleUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleUnderline selects \"underline\"."},"source":{"file":"tmux/option_generated.go","line":604,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyleUnderline","product":"core","slug":"tmux-promptcursorstyleunderline"},{"id":"tmux.PromptCursorStyleBlinkingBar","name":"PromptCursorStyleBlinkingBar","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBlinkingBar selects \"blinking-bar\"."},"source":{"file":"tmux/option_generated.go","line":606,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyleBlinkingBar","product":"core","slug":"tmux-promptcursorstyleblinkingbar"},{"id":"tmux.PromptCursorStyleBar","name":"PromptCursorStyleBar","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBar selects \"bar\"."},"source":{"file":"tmux/option_generated.go","line":608,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyleBar","product":"core","slug":"tmux-promptcursorstylebar"},{"id":"tmux.PromptCursorStyle.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PromptCursorStyle","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":612,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyle.String","product":"core","slug":"tmux-promptcursorstyle-string"},{"id":"tmux.PromptCursorStyle.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PromptCursorStyle","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":615,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptCursorStyle.Valid","product":"core","slug":"tmux-promptcursorstyle-valid"},{"id":"tmux.RemainOnExit","name":"RemainOnExit","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RemainOnExit is a typed value for the \"remain-on-exit\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":625,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RemainOnExit","product":"core","slug":"tmux-remainonexit"},{"id":"tmux.RemainOnExitOff","name":"RemainOnExitOff","kind":"constant","modifiers":[],"signatures":[],"type":"RemainOnExit","doc":{"summary":"RemainOnExitOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":629,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RemainOnExitOff","product":"core","slug":"tmux-remainonexitoff"},{"id":"tmux.RemainOnExitOn","name":"RemainOnExitOn","kind":"constant","modifiers":[],"signatures":[],"type":"RemainOnExit","doc":{"summary":"RemainOnExitOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":631,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RemainOnExitOn","product":"core","slug":"tmux-remainonexiton"},{"id":"tmux.RemainOnExitFailed","name":"RemainOnExitFailed","kind":"constant","modifiers":[],"signatures":[],"type":"RemainOnExit","doc":{"summary":"RemainOnExitFailed selects \"failed\"."},"source":{"file":"tmux/option_generated.go","line":633,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RemainOnExitFailed","product":"core","slug":"tmux-remainonexitfailed"},{"id":"tmux.RemainOnExitKey","name":"RemainOnExitKey","kind":"constant","modifiers":[],"signatures":[],"type":"RemainOnExit","doc":{"summary":"RemainOnExitKey selects \"key\"."},"source":{"file":"tmux/option_generated.go","line":635,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RemainOnExitKey","product":"core","slug":"tmux-remainonexitkey"},{"id":"tmux.RemainOnExit.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.RemainOnExit","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":639,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RemainOnExit.String","product":"core","slug":"tmux-remainonexit-string"},{"id":"tmux.RemainOnExit.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.RemainOnExit","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":642,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RemainOnExit.Valid","product":"core","slug":"tmux-remainonexit-valid"},{"id":"tmux.SetClipboard","name":"SetClipboard","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetClipboard is a typed value for the \"set-clipboard\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":652,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetClipboard","product":"core","slug":"tmux-setclipboard"},{"id":"tmux.SetClipboardOff","name":"SetClipboardOff","kind":"constant","modifiers":[],"signatures":[],"type":"SetClipboard","doc":{"summary":"SetClipboardOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":656,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetClipboardOff","product":"core","slug":"tmux-setclipboardoff"},{"id":"tmux.SetClipboardExternal","name":"SetClipboardExternal","kind":"constant","modifiers":[],"signatures":[],"type":"SetClipboard","doc":{"summary":"SetClipboardExternal selects \"external\"."},"source":{"file":"tmux/option_generated.go","line":658,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetClipboardExternal","product":"core","slug":"tmux-setclipboardexternal"},{"id":"tmux.SetClipboardOn","name":"SetClipboardOn","kind":"constant","modifiers":[],"signatures":[],"type":"SetClipboard","doc":{"summary":"SetClipboardOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":660,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetClipboardOn","product":"core","slug":"tmux-setclipboardon"},{"id":"tmux.SetClipboard.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.SetClipboard","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":664,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetClipboard.String","product":"core","slug":"tmux-setclipboard-string"},{"id":"tmux.SetClipboard.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.SetClipboard","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":667,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetClipboard.Valid","product":"core","slug":"tmux-setclipboard-valid"},{"id":"tmux.SilenceAction","name":"SilenceAction","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SilenceAction is a typed value for the \"silence-action\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":677,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SilenceAction","product":"core","slug":"tmux-silenceaction"},{"id":"tmux.SilenceActionNone","name":"SilenceActionNone","kind":"constant","modifiers":[],"signatures":[],"type":"SilenceAction","doc":{"summary":"SilenceActionNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":681,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SilenceActionNone","product":"core","slug":"tmux-silenceactionnone"},{"id":"tmux.SilenceActionAny","name":"SilenceActionAny","kind":"constant","modifiers":[],"signatures":[],"type":"SilenceAction","doc":{"summary":"SilenceActionAny selects \"any\"."},"source":{"file":"tmux/option_generated.go","line":683,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SilenceActionAny","product":"core","slug":"tmux-silenceactionany"},{"id":"tmux.SilenceActionCurrent","name":"SilenceActionCurrent","kind":"constant","modifiers":[],"signatures":[],"type":"SilenceAction","doc":{"summary":"SilenceActionCurrent selects \"current\"."},"source":{"file":"tmux/option_generated.go","line":685,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SilenceActionCurrent","product":"core","slug":"tmux-silenceactioncurrent"},{"id":"tmux.SilenceActionOther","name":"SilenceActionOther","kind":"constant","modifiers":[],"signatures":[],"type":"SilenceAction","doc":{"summary":"SilenceActionOther selects \"other\"."},"source":{"file":"tmux/option_generated.go","line":687,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SilenceActionOther","product":"core","slug":"tmux-silenceactionother"},{"id":"tmux.SilenceAction.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.SilenceAction","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":691,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SilenceAction.String","product":"core","slug":"tmux-silenceaction-string"},{"id":"tmux.SilenceAction.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.SilenceAction","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":694,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SilenceAction.Valid","product":"core","slug":"tmux-silenceaction-valid"},{"id":"tmux.Status","name":"Status","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Status is a typed value for the \"status\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":704,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Status","product":"core","slug":"tmux-status"},{"id":"tmux.StatusOff","name":"StatusOff","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"StatusOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":708,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusOff","product":"core","slug":"tmux-statusoff"},{"id":"tmux.StatusOn","name":"StatusOn","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"StatusOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":710,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusOn","product":"core","slug":"tmux-statuson"},{"id":"tmux.Status2","name":"Status2","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"Status2 selects \"2\"."},"source":{"file":"tmux/option_generated.go","line":712,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Status2","product":"core","slug":"tmux-status2"},{"id":"tmux.Status3","name":"Status3","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"Status3 selects \"3\"."},"source":{"file":"tmux/option_generated.go","line":714,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Status3","product":"core","slug":"tmux-status3"},{"id":"tmux.Status4","name":"Status4","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"Status4 selects \"4\"."},"source":{"file":"tmux/option_generated.go","line":716,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Status4","product":"core","slug":"tmux-status4"},{"id":"tmux.Status5","name":"Status5","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"Status5 selects \"5\"."},"source":{"file":"tmux/option_generated.go","line":718,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Status5","product":"core","slug":"tmux-status5"},{"id":"tmux.Status.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Status","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":722,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Status.String","product":"core","slug":"tmux-status-string"},{"id":"tmux.Status.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.Status","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":725,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Status.Valid","product":"core","slug":"tmux-status-valid"},{"id":"tmux.StatusJustify","name":"StatusJustify","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"StatusJustify is a typed value for the \"status-justify\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":735,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusJustify","product":"core","slug":"tmux-statusjustify"},{"id":"tmux.StatusJustifyLeft","name":"StatusJustifyLeft","kind":"constant","modifiers":[],"signatures":[],"type":"StatusJustify","doc":{"summary":"StatusJustifyLeft selects \"left\"."},"source":{"file":"tmux/option_generated.go","line":739,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusJustifyLeft","product":"core","slug":"tmux-statusjustifyleft"},{"id":"tmux.StatusJustifyCentre","name":"StatusJustifyCentre","kind":"constant","modifiers":[],"signatures":[],"type":"StatusJustify","doc":{"summary":"StatusJustifyCentre selects \"centre\"."},"source":{"file":"tmux/option_generated.go","line":741,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusJustifyCentre","product":"core","slug":"tmux-statusjustifycentre"},{"id":"tmux.StatusJustifyRight","name":"StatusJustifyRight","kind":"constant","modifiers":[],"signatures":[],"type":"StatusJustify","doc":{"summary":"StatusJustifyRight selects \"right\"."},"source":{"file":"tmux/option_generated.go","line":743,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusJustifyRight","product":"core","slug":"tmux-statusjustifyright"},{"id":"tmux.StatusJustifyAbsoluteCentre","name":"StatusJustifyAbsoluteCentre","kind":"constant","modifiers":[],"signatures":[],"type":"StatusJustify","doc":{"summary":"StatusJustifyAbsoluteCentre selects \"absolute-centre\"."},"source":{"file":"tmux/option_generated.go","line":745,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusJustifyAbsoluteCentre","product":"core","slug":"tmux-statusjustifyabsolutecentre"},{"id":"tmux.StatusJustify.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.StatusJustify","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":749,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusJustify.String","product":"core","slug":"tmux-statusjustify-string"},{"id":"tmux.StatusJustify.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.StatusJustify","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":752,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusJustify.Valid","product":"core","slug":"tmux-statusjustify-valid"},{"id":"tmux.StatusKeys","name":"StatusKeys","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"StatusKeys is a typed value for the \"status-keys\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":762,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusKeys","product":"core","slug":"tmux-statuskeys"},{"id":"tmux.StatusKeysEmacs","name":"StatusKeysEmacs","kind":"constant","modifiers":[],"signatures":[],"type":"StatusKeys","doc":{"summary":"StatusKeysEmacs selects \"emacs\"."},"source":{"file":"tmux/option_generated.go","line":766,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusKeysEmacs","product":"core","slug":"tmux-statuskeysemacs"},{"id":"tmux.StatusKeysVi","name":"StatusKeysVi","kind":"constant","modifiers":[],"signatures":[],"type":"StatusKeys","doc":{"summary":"StatusKeysVi selects \"vi\"."},"source":{"file":"tmux/option_generated.go","line":768,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusKeysVi","product":"core","slug":"tmux-statuskeysvi"},{"id":"tmux.StatusKeys.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.StatusKeys","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":772,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusKeys.String","product":"core","slug":"tmux-statuskeys-string"},{"id":"tmux.StatusKeys.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.StatusKeys","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":775,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusKeys.Valid","product":"core","slug":"tmux-statuskeys-valid"},{"id":"tmux.StatusPosition","name":"StatusPosition","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"StatusPosition is a typed value for the \"status-position\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":785,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusPosition","product":"core","slug":"tmux-statusposition"},{"id":"tmux.StatusPositionTop","name":"StatusPositionTop","kind":"constant","modifiers":[],"signatures":[],"type":"StatusPosition","doc":{"summary":"StatusPositionTop selects \"top\"."},"source":{"file":"tmux/option_generated.go","line":789,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusPositionTop","product":"core","slug":"tmux-statuspositiontop"},{"id":"tmux.StatusPositionBottom","name":"StatusPositionBottom","kind":"constant","modifiers":[],"signatures":[],"type":"StatusPosition","doc":{"summary":"StatusPositionBottom selects \"bottom\"."},"source":{"file":"tmux/option_generated.go","line":791,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusPositionBottom","product":"core","slug":"tmux-statuspositionbottom"},{"id":"tmux.StatusPosition.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.StatusPosition","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":795,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusPosition.String","product":"core","slug":"tmux-statusposition-string"},{"id":"tmux.StatusPosition.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.StatusPosition","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":798,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.StatusPosition.Valid","product":"core","slug":"tmux-statusposition-valid"},{"id":"tmux.VisualActivity","name":"VisualActivity","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VisualActivity is a typed value for the \"visual-activity\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":808,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualActivity","product":"core","slug":"tmux-visualactivity"},{"id":"tmux.VisualActivityOff","name":"VisualActivityOff","kind":"constant","modifiers":[],"signatures":[],"type":"VisualActivity","doc":{"summary":"VisualActivityOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":812,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualActivityOff","product":"core","slug":"tmux-visualactivityoff"},{"id":"tmux.VisualActivityOn","name":"VisualActivityOn","kind":"constant","modifiers":[],"signatures":[],"type":"VisualActivity","doc":{"summary":"VisualActivityOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":814,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualActivityOn","product":"core","slug":"tmux-visualactivityon"},{"id":"tmux.VisualActivityBoth","name":"VisualActivityBoth","kind":"constant","modifiers":[],"signatures":[],"type":"VisualActivity","doc":{"summary":"VisualActivityBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":816,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualActivityBoth","product":"core","slug":"tmux-visualactivityboth"},{"id":"tmux.VisualActivity.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.VisualActivity","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":820,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualActivity.String","product":"core","slug":"tmux-visualactivity-string"},{"id":"tmux.VisualActivity.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.VisualActivity","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":823,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualActivity.Valid","product":"core","slug":"tmux-visualactivity-valid"},{"id":"tmux.VisualBell","name":"VisualBell","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VisualBell is a typed value for the \"visual-bell\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":833,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualBell","product":"core","slug":"tmux-visualbell"},{"id":"tmux.VisualBellOff","name":"VisualBellOff","kind":"constant","modifiers":[],"signatures":[],"type":"VisualBell","doc":{"summary":"VisualBellOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":837,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualBellOff","product":"core","slug":"tmux-visualbelloff"},{"id":"tmux.VisualBellOn","name":"VisualBellOn","kind":"constant","modifiers":[],"signatures":[],"type":"VisualBell","doc":{"summary":"VisualBellOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":839,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualBellOn","product":"core","slug":"tmux-visualbellon"},{"id":"tmux.VisualBellBoth","name":"VisualBellBoth","kind":"constant","modifiers":[],"signatures":[],"type":"VisualBell","doc":{"summary":"VisualBellBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":841,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualBellBoth","product":"core","slug":"tmux-visualbellboth"},{"id":"tmux.VisualBell.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.VisualBell","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":845,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualBell.String","product":"core","slug":"tmux-visualbell-string"},{"id":"tmux.VisualBell.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.VisualBell","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":848,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualBell.Valid","product":"core","slug":"tmux-visualbell-valid"},{"id":"tmux.VisualSilence","name":"VisualSilence","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VisualSilence is a typed value for the \"visual-silence\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":858,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualSilence","product":"core","slug":"tmux-visualsilence"},{"id":"tmux.VisualSilenceOff","name":"VisualSilenceOff","kind":"constant","modifiers":[],"signatures":[],"type":"VisualSilence","doc":{"summary":"VisualSilenceOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":862,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualSilenceOff","product":"core","slug":"tmux-visualsilenceoff"},{"id":"tmux.VisualSilenceOn","name":"VisualSilenceOn","kind":"constant","modifiers":[],"signatures":[],"type":"VisualSilence","doc":{"summary":"VisualSilenceOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":864,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualSilenceOn","product":"core","slug":"tmux-visualsilenceon"},{"id":"tmux.VisualSilenceBoth","name":"VisualSilenceBoth","kind":"constant","modifiers":[],"signatures":[],"type":"VisualSilence","doc":{"summary":"VisualSilenceBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":866,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualSilenceBoth","product":"core","slug":"tmux-visualsilenceboth"},{"id":"tmux.VisualSilence.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.VisualSilence","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":870,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualSilence.String","product":"core","slug":"tmux-visualsilence-string"},{"id":"tmux.VisualSilence.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.VisualSilence","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":873,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VisualSilence.Valid","product":"core","slug":"tmux-visualsilence-valid"},{"id":"tmux.WindowSize","name":"WindowSize","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowSize is a typed value for the \"window-size\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":883,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSize","product":"core","slug":"tmux-windowsize"},{"id":"tmux.WindowSizeLargest","name":"WindowSizeLargest","kind":"constant","modifiers":[],"signatures":[],"type":"WindowSize","doc":{"summary":"WindowSizeLargest selects \"largest\"."},"source":{"file":"tmux/option_generated.go","line":887,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSizeLargest","product":"core","slug":"tmux-windowsizelargest"},{"id":"tmux.WindowSizeSmallest","name":"WindowSizeSmallest","kind":"constant","modifiers":[],"signatures":[],"type":"WindowSize","doc":{"summary":"WindowSizeSmallest selects \"smallest\"."},"source":{"file":"tmux/option_generated.go","line":889,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSizeSmallest","product":"core","slug":"tmux-windowsizesmallest"},{"id":"tmux.WindowSizeManual","name":"WindowSizeManual","kind":"constant","modifiers":[],"signatures":[],"type":"WindowSize","doc":{"summary":"WindowSizeManual selects \"manual\"."},"source":{"file":"tmux/option_generated.go","line":891,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSizeManual","product":"core","slug":"tmux-windowsizemanual"},{"id":"tmux.WindowSizeLatest","name":"WindowSizeLatest","kind":"constant","modifiers":[],"signatures":[],"type":"WindowSize","doc":{"summary":"WindowSizeLatest selects \"latest\"."},"source":{"file":"tmux/option_generated.go","line":893,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSizeLatest","product":"core","slug":"tmux-windowsizelatest"},{"id":"tmux.WindowSize.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.WindowSize","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":897,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSize.String","product":"core","slug":"tmux-windowsize-string"},{"id":"tmux.WindowSize.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.WindowSize","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":900,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSize.Valid","product":"core","slug":"tmux-windowsize-valid"},{"id":"tmux.ControlNotificationKind","name":"ControlNotificationKind","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlNotificationKind identifies a tmux control-mode notification record. Its zero value is unknown and is not emitted by tmux. [ParseControlNotification] returns known values for the pinned wire vocabulary and rejects unknown notification records."},"source":{"file":"tmux/option_generated.go","line":963,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationKind","product":"core","slug":"tmux-controlnotificationkind"},{"id":"tmux.ControlNotificationClientDetached","name":"ControlNotificationClientDetached","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationClientDetached identifies the %client-detached notification, available since tmux 3.2a. Its wire grammar is %client-detached <client>. ParseControlNotification returns its arguments as client tail."},"source":{"file":"tmux/option_generated.go","line":1683,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationClientDetached","product":"core","slug":"tmux-controlnotificationclientdetached"},{"id":"tmux.ControlNotificationClientSessionChanged","name":"ControlNotificationClientSessionChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationClientSessionChanged identifies the %client-session-changed notification, available since tmux 3.2a. Its wire grammar is %client-session-changed <client> <session ID> <session name>. ParseControlNotification returns its arguments as client, session ID, session name tail."},"source":{"file":"tmux/option_generated.go","line":1686,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationClientSessionChanged","product":"core","slug":"tmux-controlnotificationclientsessionchanged"},{"id":"tmux.ControlNotificationConfigError","name":"ControlNotificationConfigError","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationConfigError identifies the %config-error notification, available since tmux 3.4. Its wire grammar is %config-error <text>. ParseControlNotification returns its arguments as text tail."},"source":{"file":"tmux/option_generated.go","line":1689,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationConfigError","product":"core","slug":"tmux-controlnotificationconfigerror"},{"id":"tmux.ControlNotificationContinue","name":"ControlNotificationContinue","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationContinue identifies the %continue notification, available since tmux 3.2a. Its wire grammar is %continue <pane ID>. ParseControlNotification returns its arguments as pane ID."},"source":{"file":"tmux/option_generated.go","line":1692,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationContinue","product":"core","slug":"tmux-controlnotificationcontinue"},{"id":"tmux.ControlNotificationExit","name":"ControlNotificationExit","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationExit identifies the %exit notification, available since tmux 3.2a. Its wire grammar is %exit or %exit <reason>. ParseControlNotification returns its arguments as reason tail."},"source":{"file":"tmux/option_generated.go","line":1695,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationExit","product":"core","slug":"tmux-controlnotificationexit"},{"id":"tmux.ControlNotificationExtendedOutput","name":"ControlNotificationExtendedOutput","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationExtendedOutput identifies the %extended-output notification, available since tmux 3.2a. Its wire grammar is %extended-output <pane ID> <age> { zero or more <reserved argument> } : <data>. ParseControlNotification returns its arguments as the prefix arguments, then zero or more reserved arguments, then the data tail; the prefix arguments are pane ID, age. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1699,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationExtendedOutput","product":"core","slug":"tmux-controlnotificationextendedoutput"},{"id":"tmux.ControlNotificationLayoutChange","name":"ControlNotificationLayoutChange","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationLayoutChange identifies the %layout-change notification, available since tmux 3.2a. Its wire grammar is %layout-change <window ID> <layout> <visible layout> <flags>. ParseControlNotification returns its arguments as window ID, layout, visible layout, flags tail. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1703,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationLayoutChange","product":"core","slug":"tmux-controlnotificationlayoutchange"},{"id":"tmux.ControlNotificationMessage","name":"ControlNotificationMessage","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationMessage identifies the %message notification, available since tmux 3.4. Its wire grammar is %message <text>. ParseControlNotification returns its arguments as text tail. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1707,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationMessage","product":"core","slug":"tmux-controlnotificationmessage"},{"id":"tmux.ControlNotificationOutput","name":"ControlNotificationOutput","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationOutput identifies the %output notification, available since tmux 3.2a. Its wire grammar is %output <pane ID> <data>. ParseControlNotification returns its arguments as pane ID, data tail. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1711,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationOutput","product":"core","slug":"tmux-controlnotificationoutput"},{"id":"tmux.ControlNotificationPaneModeChanged","name":"ControlNotificationPaneModeChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationPaneModeChanged identifies the %pane-mode-changed notification, available since tmux 3.2a. Its wire grammar is %pane-mode-changed <pane ID>. ParseControlNotification returns its arguments as pane ID."},"source":{"file":"tmux/option_generated.go","line":1714,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationPaneModeChanged","product":"core","slug":"tmux-controlnotificationpanemodechanged"},{"id":"tmux.ControlNotificationPasteBufferChanged","name":"ControlNotificationPasteBufferChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationPasteBufferChanged identifies the %paste-buffer-changed notification, available since tmux 3.4. Its wire grammar is %paste-buffer-changed <name>. ParseControlNotification returns its arguments as name tail."},"source":{"file":"tmux/option_generated.go","line":1717,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationPasteBufferChanged","product":"core","slug":"tmux-controlnotificationpastebufferchanged"},{"id":"tmux.ControlNotificationPasteBufferDeleted","name":"ControlNotificationPasteBufferDeleted","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationPasteBufferDeleted identifies the %paste-buffer-deleted notification, available since tmux 3.4. Its wire grammar is %paste-buffer-deleted <name>. ParseControlNotification returns its arguments as name tail."},"source":{"file":"tmux/option_generated.go","line":1720,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationPasteBufferDeleted","product":"core","slug":"tmux-controlnotificationpastebufferdeleted"},{"id":"tmux.ControlNotificationPause","name":"ControlNotificationPause","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationPause identifies the %pause notification, available since tmux 3.2a. Its wire grammar is %pause <pane ID>. ParseControlNotification returns its arguments as pane ID."},"source":{"file":"tmux/option_generated.go","line":1723,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationPause","product":"core","slug":"tmux-controlnotificationpause"},{"id":"tmux.ControlNotificationSessionChanged","name":"ControlNotificationSessionChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSessionChanged identifies the %session-changed notification, available since tmux 3.2a. Its wire grammar is %session-changed <session ID> <session name>. ParseControlNotification returns its arguments as session ID, session name tail."},"source":{"file":"tmux/option_generated.go","line":1726,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationSessionChanged","product":"core","slug":"tmux-controlnotificationsessionchanged"},{"id":"tmux.ControlNotificationSessionRenamed","name":"ControlNotificationSessionRenamed","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSessionRenamed identifies the %session-renamed notification, available since tmux 3.2a. Its wire grammar is %session-renamed <session ID> <session name>. ParseControlNotification returns its arguments as session ID, session name tail."},"source":{"file":"tmux/option_generated.go","line":1729,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationSessionRenamed","product":"core","slug":"tmux-controlnotificationsessionrenamed"},{"id":"tmux.ControlNotificationSessionWindowChanged","name":"ControlNotificationSessionWindowChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSessionWindowChanged identifies the %session-window-changed notification, available since tmux 3.2a. Its wire grammar is %session-window-changed <session ID> <window ID>. ParseControlNotification returns its arguments as session ID, window ID."},"source":{"file":"tmux/option_generated.go","line":1732,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationSessionWindowChanged","product":"core","slug":"tmux-controlnotificationsessionwindowchanged"},{"id":"tmux.ControlNotificationSessionsChanged","name":"ControlNotificationSessionsChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSessionsChanged identifies the %sessions-changed notification, available since tmux 3.2a. Its wire grammar is %sessions-changed. ParseControlNotification returns its arguments as no arguments."},"source":{"file":"tmux/option_generated.go","line":1735,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationSessionsChanged","product":"core","slug":"tmux-controlnotificationsessionschanged"},{"id":"tmux.ControlNotificationSubscriptionChanged","name":"ControlNotificationSubscriptionChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSubscriptionChanged identifies the %subscription-changed notification, available since tmux 3.2a. Its wire grammar is %subscription-changed <name> <session ID> <window ID> <window index> <pane ID> { zero or more <reserved argument> } : <value>. ParseControlNotification returns its arguments as the prefix arguments, then zero or more reserved arguments, then the value tail; the prefix arguments are name, session ID, window ID, window index, pane ID. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1739,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationSubscriptionChanged","product":"core","slug":"tmux-controlnotificationsubscriptionchanged"},{"id":"tmux.ControlNotificationUnlinkedWindowAdd","name":"ControlNotificationUnlinkedWindowAdd","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationUnlinkedWindowAdd identifies the %unlinked-window-add notification, available since tmux 3.2a. Its wire grammar is %unlinked-window-add <window ID>. ParseControlNotification returns its arguments as window ID."},"source":{"file":"tmux/option_generated.go","line":1742,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationUnlinkedWindowAdd","product":"core","slug":"tmux-controlnotificationunlinkedwindowadd"},{"id":"tmux.ControlNotificationUnlinkedWindowClose","name":"ControlNotificationUnlinkedWindowClose","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationUnlinkedWindowClose identifies the %unlinked-window-close notification, available since tmux 3.2a. Its wire grammar is %unlinked-window-close <window ID>. ParseControlNotification returns its arguments as window ID."},"source":{"file":"tmux/option_generated.go","line":1745,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationUnlinkedWindowClose","product":"core","slug":"tmux-controlnotificationunlinkedwindowclose"},{"id":"tmux.ControlNotificationUnlinkedWindowRenamed","name":"ControlNotificationUnlinkedWindowRenamed","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationUnlinkedWindowRenamed identifies the %unlinked-window-renamed notification, available since tmux 3.2a. Its wire grammar is %unlinked-window-renamed <window ID> <name>. ParseControlNotification returns its arguments as window ID, name tail."},"source":{"file":"tmux/option_generated.go","line":1748,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationUnlinkedWindowRenamed","product":"core","slug":"tmux-controlnotificationunlinkedwindowrenamed"},{"id":"tmux.ControlNotificationWindowAdd","name":"ControlNotificationWindowAdd","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationWindowAdd identifies the %window-add notification, available since tmux 3.2a. Its wire grammar is %window-add <window ID>. ParseControlNotification returns its arguments as window ID."},"source":{"file":"tmux/option_generated.go","line":1751,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationWindowAdd","product":"core","slug":"tmux-controlnotificationwindowadd"},{"id":"tmux.ControlNotificationWindowClose","name":"ControlNotificationWindowClose","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationWindowClose identifies the %window-close notification, available since tmux 3.2a. Its wire grammar is %window-close <window ID>. ParseControlNotification returns its arguments as window ID."},"source":{"file":"tmux/option_generated.go","line":1754,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationWindowClose","product":"core","slug":"tmux-controlnotificationwindowclose"},{"id":"tmux.ControlNotificationWindowPaneChanged","name":"ControlNotificationWindowPaneChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationWindowPaneChanged identifies the %window-pane-changed notification, available since tmux 3.2a. Its wire grammar is %window-pane-changed <window ID> <pane ID>. ParseControlNotification returns its arguments as window ID, pane ID."},"source":{"file":"tmux/option_generated.go","line":1757,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationWindowPaneChanged","product":"core","slug":"tmux-controlnotificationwindowpanechanged"},{"id":"tmux.ControlNotificationWindowRenamed","name":"ControlNotificationWindowRenamed","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationWindowRenamed identifies the %window-renamed notification, available since tmux 3.2a. Its wire grammar is %window-renamed <window ID> <name>. ParseControlNotification returns its arguments as window ID, name tail."},"source":{"file":"tmux/option_generated.go","line":1760,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationWindowRenamed","product":"core","slug":"tmux-controlnotificationwindowrenamed"},{"id":"tmux.ControlNotificationKind.MinimumVersion","name":"MinimumVersion","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationKind","signatures":[{"params":[],"returns":"(Version, bool)"}],"doc":{"summary":"MinimumVersion returns the oldest [Version] that emits k. It returns ok == false for the zero value and unknown kinds."},"source":{"file":"tmux/option_generated.go","line":1793,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ControlNotificationKind.MinimumVersion","product":"core","slug":"tmux-controlnotificationkind-minimumversion"},{"id":"tmux.ServerOptionValues","name":"ServerOptionValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerOptionValues is an immutable materialized view of known server option values; its zero value is empty and it does not refresh. Obtain it with [Server.Options]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Server.RawOption] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":1816,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues","product":"core","slug":"tmux-serveroptionvalues"},{"id":"tmux.ServerOptionValues.Backspace","name":"Backspace","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"Backspace returns materialized \"backspace\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as KEY since tmux 3.2a; set it with [Server.SetBackspace]."},"source":{"file":"tmux/option_generated.go","line":1846,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.Backspace","product":"core","slug":"tmux-serveroptionvalues-backspace"},{"id":"tmux.ServerOptionValues.BufferLimit","name":"BufferLimit","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"BufferLimit returns materialized \"buffer-limit\" as [OptionValue] with value type OptionValue[int64] from server option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Server.SetBufferLimit]."},"source":{"file":"tmux/option_generated.go","line":1850,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.BufferLimit","product":"core","slug":"tmux-serveroptionvalues-bufferlimit"},{"id":"tmux.ServerOptionValues.CodepointWidths","name":"CodepointWidths","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"CodepointWidths returns materialized \"codepoint-widths\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Server.SetCodepointWidths]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1855,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.CodepointWidths","product":"core","slug":"tmux-serveroptionvalues-codepointwidths"},{"id":"tmux.ServerOptionValues.CommandAlias","name":"CommandAlias","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"CommandAlias returns materialized \"command-alias\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetCommandAlias]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1862,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.CommandAlias","product":"core","slug":"tmux-serveroptionvalues-commandalias"},{"id":"tmux.ServerOptionValues.CopyCommand","name":"CopyCommand","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyCommand returns materialized \"copy-command\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetCopyCommand]."},"source":{"file":"tmux/option_generated.go","line":1866,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.CopyCommand","product":"core","slug":"tmux-serveroptionvalues-copycommand"},{"id":"tmux.ServerOptionValues.DefaultClientCommand","name":"DefaultClientCommand","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultClientCommand returns materialized \"default-client-command\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as COMMAND since tmux 3.6; set it with [Server.SetDefaultClientCommand]."},"source":{"file":"tmux/option_generated.go","line":1870,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.DefaultClientCommand","product":"core","slug":"tmux-serveroptionvalues-defaultclientcommand"},{"id":"tmux.ServerOptionValues.DefaultTerminal","name":"DefaultTerminal","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultTerminal returns materialized \"default-terminal\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetDefaultTerminal]."},"source":{"file":"tmux/option_generated.go","line":1874,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.DefaultTerminal","product":"core","slug":"tmux-serveroptionvalues-defaultterminal"},{"id":"tmux.ServerOptionValues.Editor","name":"Editor","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"Editor returns materialized \"editor\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetEditor]."},"source":{"file":"tmux/option_generated.go","line":1878,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.Editor","product":"core","slug":"tmux-serveroptionvalues-editor"},{"id":"tmux.ServerOptionValues.EscapeTime","name":"EscapeTime","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"EscapeTime returns materialized \"escape-time\" as [OptionValue] with value type OptionValue[time.Duration] from server option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Server.SetEscapeTime]."},"source":{"file":"tmux/option_generated.go","line":1882,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.EscapeTime","product":"core","slug":"tmux-serveroptionvalues-escapetime"},{"id":"tmux.ServerOptionValues.ExitEmpty","name":"ExitEmpty","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"ExitEmpty returns materialized \"exit-empty\" as [OptionValue] with value type OptionValue[bool] from server option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Server.SetExitEmpty]."},"source":{"file":"tmux/option_generated.go","line":1886,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.ExitEmpty","product":"core","slug":"tmux-serveroptionvalues-exitempty"},{"id":"tmux.ServerOptionValues.ExitUnattached","name":"ExitUnattached","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"ExitUnattached returns materialized \"exit-unattached\" as [OptionValue] with value type OptionValue[bool] from server option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Server.SetExitUnattached]."},"source":{"file":"tmux/option_generated.go","line":1890,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.ExitUnattached","product":"core","slug":"tmux-serveroptionvalues-exitunattached"},{"id":"tmux.ServerOptionValues.ExtendedKeys","name":"ExtendedKeys","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[ExtendedKeys]"}],"doc":{"summary":"ExtendedKeys returns materialized \"extended-keys\" as [OptionValue] with value type OptionValue[ExtendedKeys] from server option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"always\"); set it with [Server.SetExtendedKeys]."},"source":{"file":"tmux/option_generated.go","line":1894,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.ExtendedKeys","product":"core","slug":"tmux-serveroptionvalues-extendedkeys"},{"id":"tmux.ServerOptionValues.ExtendedKeysFormat","name":"ExtendedKeysFormat","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[ExtendedKeysFormat]"}],"doc":{"summary":"ExtendedKeysFormat returns materialized \"extended-keys-format\" as [OptionValue] with value type OptionValue[ExtendedKeysFormat] from server option values; it does not query tmux. Available as CHOICE since tmux 3.5 (choices: \"csi-u\", \"xterm\"); set it with [Server.SetExtendedKeysFormat]."},"source":{"file":"tmux/option_generated.go","line":1898,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.ExtendedKeysFormat","product":"core","slug":"tmux-serveroptionvalues-extendedkeysformat"},{"id":"tmux.ServerOptionValues.FocusEvents","name":"FocusEvents","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"FocusEvents returns materialized \"focus-events\" as [OptionValue] with value type OptionValue[bool] from server option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Server.SetFocusEvents]."},"source":{"file":"tmux/option_generated.go","line":1904,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.FocusEvents","product":"core","slug":"tmux-serveroptionvalues-focusevents"},{"id":"tmux.ServerOptionValues.GetClipboard","name":"GetClipboard","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[GetClipboard]"}],"doc":{"summary":"GetClipboard returns materialized \"get-clipboard\" as [OptionValue] with value type OptionValue[GetClipboard] from server option values; it does not query tmux. Available as CHOICE since tmux 3.7 (choices: \"off\", \"buffer\", \"request\", \"both\"); set it with [Server.SetGetClipboard]."},"source":{"file":"tmux/option_generated.go","line":1908,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.GetClipboard","product":"core","slug":"tmux-serveroptionvalues-getclipboard"},{"id":"tmux.ServerOptionValues.HistoryFile","name":"HistoryFile","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"HistoryFile returns materialized \"history-file\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetHistoryFile]."},"source":{"file":"tmux/option_generated.go","line":1912,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.HistoryFile","product":"core","slug":"tmux-serveroptionvalues-historyfile"},{"id":"tmux.ServerOptionValues.InputBufferSize","name":"InputBufferSize","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"InputBufferSize returns materialized \"input-buffer-size\" as [OptionValue] with value type OptionValue[int64] from server option values; it does not query tmux. Available as NUMBER since tmux 3.6; set it with [Server.SetInputBufferSize]."},"source":{"file":"tmux/option_generated.go","line":1916,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.InputBufferSize","product":"core","slug":"tmux-serveroptionvalues-inputbuffersize"},{"id":"tmux.ServerOptionValues.MessageLimit","name":"MessageLimit","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"MessageLimit returns materialized \"message-limit\" as [OptionValue] with value type OptionValue[int64] from server option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Server.SetMessageLimit]."},"source":{"file":"tmux/option_generated.go","line":1920,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.MessageLimit","product":"core","slug":"tmux-serveroptionvalues-messagelimit"},{"id":"tmux.ServerOptionValues.PrefixTimeout","name":"PrefixTimeout","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"PrefixTimeout returns materialized \"prefix-timeout\" as [OptionValue] with value type OptionValue[time.Duration] from server option values; it does not query tmux. Available as NUMBER since tmux 3.5; set it with [Server.SetPrefixTimeout]."},"source":{"file":"tmux/option_generated.go","line":1924,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.PrefixTimeout","product":"core","slug":"tmux-serveroptionvalues-prefixtimeout"},{"id":"tmux.ServerOptionValues.PromptHistoryLimit","name":"PromptHistoryLimit","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"PromptHistoryLimit returns materialized \"prompt-history-limit\" as [OptionValue] with value type OptionValue[int64] from server option values; it does not query tmux. Available as NUMBER since tmux 3.3; set it with [Server.SetPromptHistoryLimit]."},"source":{"file":"tmux/option_generated.go","line":1928,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.PromptHistoryLimit","product":"core","slug":"tmux-serveroptionvalues-prompthistorylimit"},{"id":"tmux.ServerOptionValues.SetClipboard","name":"SetClipboard","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SetClipboard]"}],"doc":{"summary":"SetClipboard returns materialized \"set-clipboard\" as [OptionValue] with value type OptionValue[SetClipboard] from server option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"external\", \"on\"); set it with [Server.SetClipboard]."},"source":{"file":"tmux/option_generated.go","line":1932,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.SetClipboard","product":"core","slug":"tmux-serveroptionvalues-setclipboard"},{"id":"tmux.ServerOptionValues.TerminalFeatures","name":"TerminalFeatures","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"TerminalFeatures returns materialized \"terminal-features\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetTerminalFeatures]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1937,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.TerminalFeatures","product":"core","slug":"tmux-serveroptionvalues-terminalfeatures"},{"id":"tmux.ServerOptionValues.TerminalOverrides","name":"TerminalOverrides","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"TerminalOverrides returns materialized \"terminal-overrides\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetTerminalOverrides]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1944,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.TerminalOverrides","product":"core","slug":"tmux-serveroptionvalues-terminaloverrides"},{"id":"tmux.ServerOptionValues.UserKeys","name":"UserKeys","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"UserKeys returns materialized \"user-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetUserKeys]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1951,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.UserKeys","product":"core","slug":"tmux-serveroptionvalues-userkeys"},{"id":"tmux.ServerOptionValues.VariationSelectorAlwaysWide","name":"VariationSelectorAlwaysWide","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"VariationSelectorAlwaysWide returns materialized \"variation-selector-always-wide\" as [OptionValue] with value type OptionValue[bool] from server option values; it does not query tmux. Available as FLAG since tmux 3.6; set it with [Server.SetVariationSelectorAlwaysWide]."},"source":{"file":"tmux/option_generated.go","line":1955,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptionValues.VariationSelectorAlwaysWide","product":"core","slug":"tmux-serveroptionvalues-variationselectoralwayswide"},{"id":"tmux.SessionOptionValues","name":"SessionOptionValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionOptionValues is an immutable materialized view of known session option values; its zero value is empty and it does not refresh. Obtain it with [Session.Options] or [GlobalSessionScope.Options]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Session.RawOption] or [GlobalSessionScope.RawOption] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":2021,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues","product":"core","slug":"tmux-sessionoptionvalues"},{"id":"tmux.SessionOptionValues.ActivityAction","name":"ActivityAction","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[ActivityAction]"}],"doc":{"summary":"ActivityAction returns materialized \"activity-action\" as [OptionValue] with value type OptionValue[ActivityAction] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"none\", \"any\", \"current\", \"other\"); set it with [Session.SetActivityAction] or [GlobalSessionScope.SetActivityAction]."},"source":{"file":"tmux/option_generated.go","line":2080,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.ActivityAction","product":"core","slug":"tmux-sessionoptionvalues-activityaction"},{"id":"tmux.SessionOptionValues.AssumePasteTime","name":"AssumePasteTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"AssumePasteTime returns materialized \"assume-paste-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetAssumePasteTime] or [GlobalSessionScope.SetAssumePasteTime]."},"source":{"file":"tmux/option_generated.go","line":2084,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.AssumePasteTime","product":"core","slug":"tmux-sessionoptionvalues-assumepastetime"},{"id":"tmux.SessionOptionValues.BaseIndex","name":"BaseIndex","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"BaseIndex returns materialized \"base-index\" as [OptionValue] with value type OptionValue[int64] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetBaseIndex] or [GlobalSessionScope.SetBaseIndex]."},"source":{"file":"tmux/option_generated.go","line":2088,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.BaseIndex","product":"core","slug":"tmux-sessionoptionvalues-baseindex"},{"id":"tmux.SessionOptionValues.BellAction","name":"BellAction","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[BellAction]"}],"doc":{"summary":"BellAction returns materialized \"bell-action\" as [OptionValue] with value type OptionValue[BellAction] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"none\", \"any\", \"current\", \"other\"); set it with [Session.SetBellAction] or [GlobalSessionScope.SetBellAction]."},"source":{"file":"tmux/option_generated.go","line":2092,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.BellAction","product":"core","slug":"tmux-sessionoptionvalues-bellaction"},{"id":"tmux.SessionOptionValues.DefaultCommand","name":"DefaultCommand","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultCommand returns materialized \"default-command\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetDefaultCommand] or [GlobalSessionScope.SetDefaultCommand]."},"source":{"file":"tmux/option_generated.go","line":2096,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DefaultCommand","product":"core","slug":"tmux-sessionoptionvalues-defaultcommand"},{"id":"tmux.SessionOptionValues.DefaultShell","name":"DefaultShell","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultShell returns materialized \"default-shell\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetDefaultShell] or [GlobalSessionScope.SetDefaultShell]."},"source":{"file":"tmux/option_generated.go","line":2100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DefaultShell","product":"core","slug":"tmux-sessionoptionvalues-defaultshell"},{"id":"tmux.SessionOptionValues.DefaultSize","name":"DefaultSize","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultSize returns materialized \"default-size\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetDefaultSize] or [GlobalSessionScope.SetDefaultSize]."},"source":{"file":"tmux/option_generated.go","line":2104,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DefaultSize","product":"core","slug":"tmux-sessionoptionvalues-defaultsize"},{"id":"tmux.SessionOptionValues.DestroyUnattached","name":"DestroyUnattached","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[DestroyUnattached]"}],"doc":{"summary":"DestroyUnattached returns materialized \"destroy-unattached\" as [OptionValue] with value type OptionValue[DestroyUnattached] from session option values; it does not query tmux. Available as FLAG since tmux 3.2a; CHOICE since tmux 3.4 (choices: \"off\", \"on\", \"keep-last\", \"keep-group\"); set it with [Session.SetDestroyUnattached] or [GlobalSessionScope.SetDestroyUnattached]."},"source":{"file":"tmux/option_generated.go","line":2108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DestroyUnattached","product":"core","slug":"tmux-sessionoptionvalues-destroyunattached"},{"id":"tmux.SessionOptionValues.DetachOnDestroy","name":"DetachOnDestroy","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[DetachOnDestroy]"}],"doc":{"summary":"DetachOnDestroy returns materialized \"detach-on-destroy\" as [OptionValue] with value type OptionValue[DetachOnDestroy] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"no-detached\"); CHOICE since tmux 3.4 (choices: \"off\", \"on\", \"no-detached\", \"previous\", \"next\"); set it with [Session.SetDetachOnDestroy] or [GlobalSessionScope.SetDetachOnDestroy]."},"source":{"file":"tmux/option_generated.go","line":2114,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DetachOnDestroy","product":"core","slug":"tmux-sessionoptionvalues-detachondestroy"},{"id":"tmux.SessionOptionValues.DisplayPanesActiveColour","name":"DisplayPanesActiveColour","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DisplayPanesActiveColour returns materialized \"display-panes-active-colour\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Session.SetDisplayPanesActiveColour] or [GlobalSessionScope.SetDisplayPanesActiveColour]."},"source":{"file":"tmux/option_generated.go","line":2118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DisplayPanesActiveColour","product":"core","slug":"tmux-sessionoptionvalues-displaypanesactivecolour"},{"id":"tmux.SessionOptionValues.DisplayPanesColour","name":"DisplayPanesColour","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DisplayPanesColour returns materialized \"display-panes-colour\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Session.SetDisplayPanesColour] or [GlobalSessionScope.SetDisplayPanesColour]."},"source":{"file":"tmux/option_generated.go","line":2124,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DisplayPanesColour","product":"core","slug":"tmux-sessionoptionvalues-displaypanescolour"},{"id":"tmux.SessionOptionValues.DisplayPanesTime","name":"DisplayPanesTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"DisplayPanesTime returns materialized \"display-panes-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetDisplayPanesTime] or [GlobalSessionScope.SetDisplayPanesTime]."},"source":{"file":"tmux/option_generated.go","line":2128,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DisplayPanesTime","product":"core","slug":"tmux-sessionoptionvalues-displaypanestime"},{"id":"tmux.SessionOptionValues.DisplayTime","name":"DisplayTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"DisplayTime returns materialized \"display-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetDisplayTime] or [GlobalSessionScope.SetDisplayTime]."},"source":{"file":"tmux/option_generated.go","line":2132,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.DisplayTime","product":"core","slug":"tmux-sessionoptionvalues-displaytime"},{"id":"tmux.SessionOptionValues.FocusFollowsMouse","name":"FocusFollowsMouse","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"FocusFollowsMouse returns materialized \"focus-follows-mouse\" as [OptionValue] with value type OptionValue[bool] from session option values; it does not query tmux. Available as FLAG since tmux 3.7; set it with [Session.SetFocusFollowsMouse] or [GlobalSessionScope.SetFocusFollowsMouse]."},"source":{"file":"tmux/option_generated.go","line":2136,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.FocusFollowsMouse","product":"core","slug":"tmux-sessionoptionvalues-focusfollowsmouse"},{"id":"tmux.SessionOptionValues.HistoryLimit","name":"HistoryLimit","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"HistoryLimit returns materialized \"history-limit\" as [OptionValue] with value type OptionValue[int64] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetHistoryLimit] or [GlobalSessionScope.SetHistoryLimit]."},"source":{"file":"tmux/option_generated.go","line":2140,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.HistoryLimit","product":"core","slug":"tmux-sessionoptionvalues-historylimit"},{"id":"tmux.SessionOptionValues.InitialRepeatTime","name":"InitialRepeatTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"InitialRepeatTime returns materialized \"initial-repeat-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.6; set it with [Session.SetInitialRepeatTime] or [GlobalSessionScope.SetInitialRepeatTime]."},"source":{"file":"tmux/option_generated.go","line":2144,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.InitialRepeatTime","product":"core","slug":"tmux-sessionoptionvalues-initialrepeattime"},{"id":"tmux.SessionOptionValues.KeyTable","name":"KeyTable","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"KeyTable returns materialized \"key-table\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetKeyTable] or [GlobalSessionScope.SetKeyTable]."},"source":{"file":"tmux/option_generated.go","line":2150,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.KeyTable","product":"core","slug":"tmux-sessionoptionvalues-keytable"},{"id":"tmux.SessionOptionValues.LockAfterTime","name":"LockAfterTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"LockAfterTime returns materialized \"lock-after-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetLockAfterTime] or [GlobalSessionScope.SetLockAfterTime]."},"source":{"file":"tmux/option_generated.go","line":2154,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.LockAfterTime","product":"core","slug":"tmux-sessionoptionvalues-lockaftertime"},{"id":"tmux.SessionOptionValues.LockCommand","name":"LockCommand","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"LockCommand returns materialized \"lock-command\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetLockCommand] or [GlobalSessionScope.SetLockCommand]."},"source":{"file":"tmux/option_generated.go","line":2158,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.LockCommand","product":"core","slug":"tmux-sessionoptionvalues-lockcommand"},{"id":"tmux.SessionOptionValues.MessageCommandStyle","name":"MessageCommandStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MessageCommandStyle returns materialized \"message-command-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetMessageCommandStyle] or [GlobalSessionScope.SetMessageCommandStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2163,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.MessageCommandStyle","product":"core","slug":"tmux-sessionoptionvalues-messagecommandstyle"},{"id":"tmux.SessionOptionValues.MessageFormat","name":"MessageFormat","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MessageFormat returns materialized \"message-format\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Session.SetMessageFormat] or [GlobalSessionScope.SetMessageFormat]."},"source":{"file":"tmux/option_generated.go","line":2167,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.MessageFormat","product":"core","slug":"tmux-sessionoptionvalues-messageformat"},{"id":"tmux.SessionOptionValues.MessageLine","name":"MessageLine","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[MessageLine]"}],"doc":{"summary":"MessageLine returns materialized \"message-line\" as [OptionValue] with value type OptionValue[MessageLine] from session option values; it does not query tmux. Available as CHOICE since tmux 3.4 (choices: \"0\", \"1\", \"2\", \"3\", \"4\"); set it with [Session.SetMessageLine] or [GlobalSessionScope.SetMessageLine]."},"source":{"file":"tmux/option_generated.go","line":2171,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.MessageLine","product":"core","slug":"tmux-sessionoptionvalues-messageline"},{"id":"tmux.SessionOptionValues.MessageStyle","name":"MessageStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MessageStyle returns materialized \"message-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetMessageStyle] or [GlobalSessionScope.SetMessageStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2176,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.MessageStyle","product":"core","slug":"tmux-sessionoptionvalues-messagestyle"},{"id":"tmux.SessionOptionValues.Mouse","name":"Mouse","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"Mouse returns materialized \"mouse\" as [OptionValue] with value type OptionValue[bool] from session option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Session.SetMouse] or [GlobalSessionScope.SetMouse]."},"source":{"file":"tmux/option_generated.go","line":2180,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.Mouse","product":"core","slug":"tmux-sessionoptionvalues-mouse"},{"id":"tmux.SessionOptionValues.Prefix","name":"Prefix","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"Prefix returns materialized \"prefix\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as KEY since tmux 3.2a; set it with [Session.SetPrefix] or [GlobalSessionScope.SetPrefix]."},"source":{"file":"tmux/option_generated.go","line":2184,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.Prefix","product":"core","slug":"tmux-sessionoptionvalues-prefix"},{"id":"tmux.SessionOptionValues.Prefix2","name":"Prefix2","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"Prefix2 returns materialized \"prefix2\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as KEY since tmux 3.2a; set it with [Session.SetPrefix2] or [GlobalSessionScope.SetPrefix2]."},"source":{"file":"tmux/option_generated.go","line":2188,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.Prefix2","product":"core","slug":"tmux-sessionoptionvalues-prefix2"},{"id":"tmux.SessionOptionValues.PromptCommandCursorStyle","name":"PromptCommandCursorStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[PromptCommandCursorStyle]"}],"doc":{"summary":"PromptCommandCursorStyle returns materialized \"prompt-command-cursor-style\" as [OptionValue] with value type OptionValue[PromptCommandCursorStyle] from session option values; it does not query tmux. Available as CHOICE since tmux 3.7 (choices: \"default\", \"blinking-block\", \"block\", \"blinking-underline\", \"underline\", \"blinking-bar\", \"bar\"); set it with [Session.SetPromptCommandCursorStyle] or [GlobalSessionScope.SetPromptCommandCursorStyle]."},"source":{"file":"tmux/option_generated.go","line":2192,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.PromptCommandCursorStyle","product":"core","slug":"tmux-sessionoptionvalues-promptcommandcursorstyle"},{"id":"tmux.SessionOptionValues.PromptCursorColour","name":"PromptCursorColour","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PromptCursorColour returns materialized \"prompt-cursor-colour\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.6; set it with [Session.SetPromptCursorColour] or [GlobalSessionScope.SetPromptCursorColour]."},"source":{"file":"tmux/option_generated.go","line":2198,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.PromptCursorColour","product":"core","slug":"tmux-sessionoptionvalues-promptcursorcolour"},{"id":"tmux.SessionOptionValues.PromptCursorStyle","name":"PromptCursorStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[PromptCursorStyle]"}],"doc":{"summary":"PromptCursorStyle returns materialized \"prompt-cursor-style\" as [OptionValue] with value type OptionValue[PromptCursorStyle] from session option values; it does not query tmux. Available as CHOICE since tmux 3.6 (choices: \"default\", \"blinking-block\", \"block\", \"blinking-underline\", \"underline\", \"blinking-bar\", \"bar\"); set it with [Session.SetPromptCursorStyle] or [GlobalSessionScope.SetPromptCursorStyle]."},"source":{"file":"tmux/option_generated.go","line":2202,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.PromptCursorStyle","product":"core","slug":"tmux-sessionoptionvalues-promptcursorstyle"},{"id":"tmux.SessionOptionValues.RenumberWindows","name":"RenumberWindows","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"RenumberWindows returns materialized \"renumber-windows\" as [OptionValue] with value type OptionValue[bool] from session option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Session.SetRenumberWindows] or [GlobalSessionScope.SetRenumberWindows]."},"source":{"file":"tmux/option_generated.go","line":2208,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.RenumberWindows","product":"core","slug":"tmux-sessionoptionvalues-renumberwindows"},{"id":"tmux.SessionOptionValues.RepeatTime","name":"RepeatTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"RepeatTime returns materialized \"repeat-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetRepeatTime] or [GlobalSessionScope.SetRepeatTime]."},"source":{"file":"tmux/option_generated.go","line":2212,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.RepeatTime","product":"core","slug":"tmux-sessionoptionvalues-repeattime"},{"id":"tmux.SessionOptionValues.SetTitles","name":"SetTitles","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"SetTitles returns materialized \"set-titles\" as [OptionValue] with value type OptionValue[bool] from session option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Session.SetTitles] or [GlobalSessionScope.SetTitles]."},"source":{"file":"tmux/option_generated.go","line":2216,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.SetTitles","product":"core","slug":"tmux-sessionoptionvalues-settitles"},{"id":"tmux.SessionOptionValues.SetTitlesString","name":"SetTitlesString","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"SetTitlesString returns materialized \"set-titles-string\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetTitlesString] or [GlobalSessionScope.SetTitlesString]."},"source":{"file":"tmux/option_generated.go","line":2220,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.SetTitlesString","product":"core","slug":"tmux-sessionoptionvalues-settitlesstring"},{"id":"tmux.SessionOptionValues.SilenceAction","name":"SilenceAction","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[SilenceAction]"}],"doc":{"summary":"SilenceAction returns materialized \"silence-action\" as [OptionValue] with value type OptionValue[SilenceAction] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"none\", \"any\", \"current\", \"other\"); set it with [Session.SetSilenceAction] or [GlobalSessionScope.SetSilenceAction]."},"source":{"file":"tmux/option_generated.go","line":2224,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.SilenceAction","product":"core","slug":"tmux-sessionoptionvalues-silenceaction"},{"id":"tmux.SessionOptionValues.Status","name":"Status","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[Status]"}],"doc":{"summary":"Status returns materialized \"status\" as [OptionValue] with value type OptionValue[Status] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"2\", \"3\", \"4\", \"5\"); set it with [Session.SetStatus] or [GlobalSessionScope.SetStatus]."},"source":{"file":"tmux/option_generated.go","line":2228,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.Status","product":"core","slug":"tmux-sessionoptionvalues-status"},{"id":"tmux.SessionOptionValues.StatusBG","name":"StatusBG","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusBG returns materialized \"status-bg\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Session.SetStatusBG] or [GlobalSessionScope.SetStatusBG]."},"source":{"file":"tmux/option_generated.go","line":2232,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusBG","product":"core","slug":"tmux-sessionoptionvalues-statusbg"},{"id":"tmux.SessionOptionValues.StatusFG","name":"StatusFG","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusFG returns materialized \"status-fg\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Session.SetStatusFG] or [GlobalSessionScope.SetStatusFG]."},"source":{"file":"tmux/option_generated.go","line":2236,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusFG","product":"core","slug":"tmux-sessionoptionvalues-statusfg"},{"id":"tmux.SessionOptionValues.StatusFormat","name":"StatusFormat","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"StatusFormat returns materialized \"status-format\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusFormat] or [GlobalSessionScope.SetStatusFormat]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":2241,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusFormat","product":"core","slug":"tmux-sessionoptionvalues-statusformat"},{"id":"tmux.SessionOptionValues.StatusInterval","name":"StatusInterval","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"StatusInterval returns materialized \"status-interval\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetStatusInterval] or [GlobalSessionScope.SetStatusInterval]."},"source":{"file":"tmux/option_generated.go","line":2245,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusInterval","product":"core","slug":"tmux-sessionoptionvalues-statusinterval"},{"id":"tmux.SessionOptionValues.StatusJustify","name":"StatusJustify","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[StatusJustify]"}],"doc":{"summary":"StatusJustify returns materialized \"status-justify\" as [OptionValue] with value type OptionValue[StatusJustify] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"left\", \"centre\", \"right\", \"absolute-centre\"); set it with [Session.SetStatusJustify] or [GlobalSessionScope.SetStatusJustify]."},"source":{"file":"tmux/option_generated.go","line":2249,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusJustify","product":"core","slug":"tmux-sessionoptionvalues-statusjustify"},{"id":"tmux.SessionOptionValues.StatusKeys","name":"StatusKeys","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[StatusKeys]"}],"doc":{"summary":"StatusKeys returns materialized \"status-keys\" as [OptionValue] with value type OptionValue[StatusKeys] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"emacs\", \"vi\"); set it with [Session.SetStatusKeys] or [GlobalSessionScope.SetStatusKeys]."},"source":{"file":"tmux/option_generated.go","line":2253,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusKeys","product":"core","slug":"tmux-sessionoptionvalues-statuskeys"},{"id":"tmux.SessionOptionValues.StatusLeft","name":"StatusLeft","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusLeft returns materialized \"status-left\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusLeft] or [GlobalSessionScope.SetStatusLeft]."},"source":{"file":"tmux/option_generated.go","line":2257,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusLeft","product":"core","slug":"tmux-sessionoptionvalues-statusleft"},{"id":"tmux.SessionOptionValues.StatusLeftLength","name":"StatusLeftLength","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"StatusLeftLength returns materialized \"status-left-length\" as [OptionValue] with value type OptionValue[int64] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetStatusLeftLength] or [GlobalSessionScope.SetStatusLeftLength]."},"source":{"file":"tmux/option_generated.go","line":2261,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusLeftLength","product":"core","slug":"tmux-sessionoptionvalues-statusleftlength"},{"id":"tmux.SessionOptionValues.StatusLeftStyle","name":"StatusLeftStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusLeftStyle returns materialized \"status-left-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusLeftStyle] or [GlobalSessionScope.SetStatusLeftStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2266,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusLeftStyle","product":"core","slug":"tmux-sessionoptionvalues-statusleftstyle"},{"id":"tmux.SessionOptionValues.StatusPosition","name":"StatusPosition","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[StatusPosition]"}],"doc":{"summary":"StatusPosition returns materialized \"status-position\" as [OptionValue] with value type OptionValue[StatusPosition] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"top\", \"bottom\"); set it with [Session.SetStatusPosition] or [GlobalSessionScope.SetStatusPosition]."},"source":{"file":"tmux/option_generated.go","line":2270,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusPosition","product":"core","slug":"tmux-sessionoptionvalues-statusposition"},{"id":"tmux.SessionOptionValues.StatusRight","name":"StatusRight","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusRight returns materialized \"status-right\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusRight] or [GlobalSessionScope.SetStatusRight]."},"source":{"file":"tmux/option_generated.go","line":2274,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusRight","product":"core","slug":"tmux-sessionoptionvalues-statusright"},{"id":"tmux.SessionOptionValues.StatusRightLength","name":"StatusRightLength","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"StatusRightLength returns materialized \"status-right-length\" as [OptionValue] with value type OptionValue[int64] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetStatusRightLength] or [GlobalSessionScope.SetStatusRightLength]."},"source":{"file":"tmux/option_generated.go","line":2278,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusRightLength","product":"core","slug":"tmux-sessionoptionvalues-statusrightlength"},{"id":"tmux.SessionOptionValues.StatusRightStyle","name":"StatusRightStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusRightStyle returns materialized \"status-right-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusRightStyle] or [GlobalSessionScope.SetStatusRightStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2283,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusRightStyle","product":"core","slug":"tmux-sessionoptionvalues-statusrightstyle"},{"id":"tmux.SessionOptionValues.StatusStyle","name":"StatusStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusStyle returns materialized \"status-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusStyle] or [GlobalSessionScope.SetStatusStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2288,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.StatusStyle","product":"core","slug":"tmux-sessionoptionvalues-statusstyle"},{"id":"tmux.SessionOptionValues.UpdateEnvironment","name":"UpdateEnvironment","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"UpdateEnvironment returns materialized \"update-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetUpdateEnvironment] or [GlobalSessionScope.SetUpdateEnvironment]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":2293,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.UpdateEnvironment","product":"core","slug":"tmux-sessionoptionvalues-updateenvironment"},{"id":"tmux.SessionOptionValues.VisualActivity","name":"VisualActivity","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[VisualActivity]"}],"doc":{"summary":"VisualActivity returns materialized \"visual-activity\" as [OptionValue] with value type OptionValue[VisualActivity] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"both\"); set it with [Session.SetVisualActivity] or [GlobalSessionScope.SetVisualActivity]."},"source":{"file":"tmux/option_generated.go","line":2299,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.VisualActivity","product":"core","slug":"tmux-sessionoptionvalues-visualactivity"},{"id":"tmux.SessionOptionValues.VisualBell","name":"VisualBell","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[VisualBell]"}],"doc":{"summary":"VisualBell returns materialized \"visual-bell\" as [OptionValue] with value type OptionValue[VisualBell] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"both\"); set it with [Session.SetVisualBell] or [GlobalSessionScope.SetVisualBell]."},"source":{"file":"tmux/option_generated.go","line":2303,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.VisualBell","product":"core","slug":"tmux-sessionoptionvalues-visualbell"},{"id":"tmux.SessionOptionValues.VisualSilence","name":"VisualSilence","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[VisualSilence]"}],"doc":{"summary":"VisualSilence returns materialized \"visual-silence\" as [OptionValue] with value type OptionValue[VisualSilence] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"both\"); set it with [Session.SetVisualSilence] or [GlobalSessionScope.SetVisualSilence]."},"source":{"file":"tmux/option_generated.go","line":2307,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.VisualSilence","product":"core","slug":"tmux-sessionoptionvalues-visualsilence"},{"id":"tmux.SessionOptionValues.WordSeparators","name":"WordSeparators","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WordSeparators returns materialized \"word-separators\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetWordSeparators] or [GlobalSessionScope.SetWordSeparators]."},"source":{"file":"tmux/option_generated.go","line":2311,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionOptionValues.WordSeparators","product":"core","slug":"tmux-sessionoptionvalues-wordseparators"},{"id":"tmux.WindowOptionValues","name":"WindowOptionValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowOptionValues is an immutable materialized view of known window option values; its zero value is empty and it does not refresh. Obtain it with [Window.Options] or [GlobalWindowScope.Options]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Window.RawOption] or [GlobalWindowScope.RawOption] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":2433,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues","product":"core","slug":"tmux-windowoptionvalues"},{"id":"tmux.WindowOptionValues.AggressiveResize","name":"AggressiveResize","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AggressiveResize returns materialized \"aggressive-resize\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetAggressiveResize] or [GlobalWindowScope.SetAggressiveResize]."},"source":{"file":"tmux/option_generated.go","line":2512,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.AggressiveResize","product":"core","slug":"tmux-windowoptionvalues-aggressiveresize"},{"id":"tmux.WindowOptionValues.AllowPassthrough","name":"AllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[AllowPassthrough]"}],"doc":{"summary":"AllowPassthrough returns materialized \"allow-passthrough\" as [OptionValue] with value type OptionValue[AllowPassthrough] from window option values; it does not query tmux. Available as FLAG since tmux 3.3; CHOICE since tmux 3.4 (choices: \"off\", \"on\", \"all\"); set it with [Window.SetAllowPassthrough] or [GlobalWindowScope.SetAllowPassthrough]."},"source":{"file":"tmux/option_generated.go","line":2516,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.AllowPassthrough","product":"core","slug":"tmux-windowoptionvalues-allowpassthrough"},{"id":"tmux.WindowOptionValues.AllowRename","name":"AllowRename","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AllowRename returns materialized \"allow-rename\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetAllowRename] or [GlobalWindowScope.SetAllowRename]."},"source":{"file":"tmux/option_generated.go","line":2522,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.AllowRename","product":"core","slug":"tmux-windowoptionvalues-allowrename"},{"id":"tmux.WindowOptionValues.AllowSetTitle","name":"AllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AllowSetTitle returns materialized \"allow-set-title\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.5; set it with [Window.SetAllowSetTitle] or [GlobalWindowScope.SetAllowSetTitle]."},"source":{"file":"tmux/option_generated.go","line":2526,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.AllowSetTitle","product":"core","slug":"tmux-windowoptionvalues-allowsettitle"},{"id":"tmux.WindowOptionValues.AlternateScreen","name":"AlternateScreen","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AlternateScreen returns materialized \"alternate-screen\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetAlternateScreen] or [GlobalWindowScope.SetAlternateScreen]."},"source":{"file":"tmux/option_generated.go","line":2530,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.AlternateScreen","product":"core","slug":"tmux-windowoptionvalues-alternatescreen"},{"id":"tmux.WindowOptionValues.AutomaticRename","name":"AutomaticRename","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AutomaticRename returns materialized \"automatic-rename\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetAutomaticRename] or [GlobalWindowScope.SetAutomaticRename]."},"source":{"file":"tmux/option_generated.go","line":2534,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.AutomaticRename","product":"core","slug":"tmux-windowoptionvalues-automaticrename"},{"id":"tmux.WindowOptionValues.AutomaticRenameFormat","name":"AutomaticRenameFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"AutomaticRenameFormat returns materialized \"automatic-rename-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetAutomaticRenameFormat] or [GlobalWindowScope.SetAutomaticRenameFormat]."},"source":{"file":"tmux/option_generated.go","line":2538,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.AutomaticRenameFormat","product":"core","slug":"tmux-windowoptionvalues-automaticrenameformat"},{"id":"tmux.WindowOptionValues.ClockModeColour","name":"ClockModeColour","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"ClockModeColour returns materialized \"clock-mode-colour\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Window.SetClockModeColour] or [GlobalWindowScope.SetClockModeColour]."},"source":{"file":"tmux/option_generated.go","line":2544,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.ClockModeColour","product":"core","slug":"tmux-windowoptionvalues-clockmodecolour"},{"id":"tmux.WindowOptionValues.ClockModeStyle","name":"ClockModeStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[ClockModeStyle]"}],"doc":{"summary":"ClockModeStyle returns materialized \"clock-mode-style\" as [OptionValue] with value type OptionValue[ClockModeStyle] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"12\", \"24\"); CHOICE since tmux 3.6 (choices: \"12\", \"24\", \"12-with-seconds\", \"24-with-seconds\"); set it with [Window.SetClockModeStyle] or [GlobalWindowScope.SetClockModeStyle]."},"source":{"file":"tmux/option_generated.go","line":2548,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.ClockModeStyle","product":"core","slug":"tmux-windowoptionvalues-clockmodestyle"},{"id":"tmux.WindowOptionValues.CopyModeCurrentLineNumberStyle","name":"CopyModeCurrentLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeCurrentLineNumberStyle returns materialized \"copy-mode-current-line-number-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetCopyModeCurrentLineNumberStyle] or [GlobalWindowScope.SetCopyModeCurrentLineNumberStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2553,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModeCurrentLineNumberStyle","product":"core","slug":"tmux-windowoptionvalues-copymodecurrentlinenumberstyle"},{"id":"tmux.WindowOptionValues.CopyModeCurrentMatchStyle","name":"CopyModeCurrentMatchStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeCurrentMatchStyle returns materialized \"copy-mode-current-match-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetCopyModeCurrentMatchStyle] or [GlobalWindowScope.SetCopyModeCurrentMatchStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2560,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModeCurrentMatchStyle","product":"core","slug":"tmux-windowoptionvalues-copymodecurrentmatchstyle"},{"id":"tmux.WindowOptionValues.CopyModeLineNumberStyle","name":"CopyModeLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeLineNumberStyle returns materialized \"copy-mode-line-number-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetCopyModeLineNumberStyle] or [GlobalWindowScope.SetCopyModeLineNumberStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2567,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModeLineNumberStyle","product":"core","slug":"tmux-windowoptionvalues-copymodelinenumberstyle"},{"id":"tmux.WindowOptionValues.CopyModeLineNumbers","name":"CopyModeLineNumbers","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[CopyModeLineNumbers]"}],"doc":{"summary":"CopyModeLineNumbers returns materialized \"copy-mode-line-numbers\" as [OptionValue] with value type OptionValue[CopyModeLineNumbers] from window option values; it does not query tmux. Available as CHOICE since tmux 3.7 (choices: \"off\", \"default\", \"absolute\", \"relative\", \"hybrid\"); set it with [Window.SetCopyModeLineNumbers] or [GlobalWindowScope.SetCopyModeLineNumbers]."},"source":{"file":"tmux/option_generated.go","line":2573,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModeLineNumbers","product":"core","slug":"tmux-windowoptionvalues-copymodelinenumbers"},{"id":"tmux.WindowOptionValues.CopyModeMarkStyle","name":"CopyModeMarkStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeMarkStyle returns materialized \"copy-mode-mark-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetCopyModeMarkStyle] or [GlobalWindowScope.SetCopyModeMarkStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2580,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModeMarkStyle","product":"core","slug":"tmux-windowoptionvalues-copymodemarkstyle"},{"id":"tmux.WindowOptionValues.CopyModeMatchStyle","name":"CopyModeMatchStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeMatchStyle returns materialized \"copy-mode-match-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetCopyModeMatchStyle] or [GlobalWindowScope.SetCopyModeMatchStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2585,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModeMatchStyle","product":"core","slug":"tmux-windowoptionvalues-copymodematchstyle"},{"id":"tmux.WindowOptionValues.CopyModePositionFormat","name":"CopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModePositionFormat returns materialized \"copy-mode-position-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetCopyModePositionFormat] or [GlobalWindowScope.SetCopyModePositionFormat]."},"source":{"file":"tmux/option_generated.go","line":2589,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModePositionFormat","product":"core","slug":"tmux-windowoptionvalues-copymodepositionformat"},{"id":"tmux.WindowOptionValues.CopyModePositionStyle","name":"CopyModePositionStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModePositionStyle returns materialized \"copy-mode-position-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetCopyModePositionStyle] or [GlobalWindowScope.SetCopyModePositionStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2596,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModePositionStyle","product":"core","slug":"tmux-windowoptionvalues-copymodepositionstyle"},{"id":"tmux.WindowOptionValues.CopyModeSelectionStyle","name":"CopyModeSelectionStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeSelectionStyle returns materialized \"copy-mode-selection-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetCopyModeSelectionStyle] or [GlobalWindowScope.SetCopyModeSelectionStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2603,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CopyModeSelectionStyle","product":"core","slug":"tmux-windowoptionvalues-copymodeselectionstyle"},{"id":"tmux.WindowOptionValues.CursorColour","name":"CursorColour","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CursorColour returns materialized \"cursor-colour\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as COLOUR since tmux 3.3; set it with [Window.SetCursorColour] or [GlobalWindowScope.SetCursorColour]."},"source":{"file":"tmux/option_generated.go","line":2609,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CursorColour","product":"core","slug":"tmux-windowoptionvalues-cursorcolour"},{"id":"tmux.WindowOptionValues.CursorStyle","name":"CursorStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[CursorStyle]"}],"doc":{"summary":"CursorStyle returns materialized \"cursor-style\" as [OptionValue] with value type OptionValue[CursorStyle] from window option values; it does not query tmux. Available as CHOICE since tmux 3.3 (choices: \"default\", \"blinking-block\", \"block\", \"blinking-underline\", \"underline\", \"blinking-bar\", \"bar\"); set it with [Window.SetCursorStyle] or [GlobalWindowScope.SetCursorStyle]."},"source":{"file":"tmux/option_generated.go","line":2613,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.CursorStyle","product":"core","slug":"tmux-windowoptionvalues-cursorstyle"},{"id":"tmux.WindowOptionValues.FillCharacter","name":"FillCharacter","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"FillCharacter returns materialized \"fill-character\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Window.SetFillCharacter] or [GlobalWindowScope.SetFillCharacter]."},"source":{"file":"tmux/option_generated.go","line":2617,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.FillCharacter","product":"core","slug":"tmux-windowoptionvalues-fillcharacter"},{"id":"tmux.WindowOptionValues.MainPaneHeight","name":"MainPaneHeight","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MainPaneHeight returns materialized \"main-pane-height\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetMainPaneHeight] or [GlobalWindowScope.SetMainPaneHeight]."},"source":{"file":"tmux/option_generated.go","line":2621,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MainPaneHeight","product":"core","slug":"tmux-windowoptionvalues-mainpaneheight"},{"id":"tmux.WindowOptionValues.MainPaneWidth","name":"MainPaneWidth","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MainPaneWidth returns materialized \"main-pane-width\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetMainPaneWidth] or [GlobalWindowScope.SetMainPaneWidth]."},"source":{"file":"tmux/option_generated.go","line":2625,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MainPaneWidth","product":"core","slug":"tmux-windowoptionvalues-mainpanewidth"},{"id":"tmux.WindowOptionValues.MenuBorderLines","name":"MenuBorderLines","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[MenuBorderLines]"}],"doc":{"summary":"MenuBorderLines returns materialized \"menu-border-lines\" as [OptionValue] with value type OptionValue[MenuBorderLines] from window option values; it does not query tmux. Available as CHOICE since tmux 3.4 (choices: \"single\", \"double\", \"heavy\", \"simple\", \"rounded\", \"padded\", \"none\"); set it with [Window.SetMenuBorderLines] or [GlobalWindowScope.SetMenuBorderLines]."},"source":{"file":"tmux/option_generated.go","line":2629,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MenuBorderLines","product":"core","slug":"tmux-windowoptionvalues-menuborderlines"},{"id":"tmux.WindowOptionValues.MenuBorderStyle","name":"MenuBorderStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MenuBorderStyle returns materialized \"menu-border-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.4; set it with [Window.SetMenuBorderStyle] or [GlobalWindowScope.SetMenuBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2634,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MenuBorderStyle","product":"core","slug":"tmux-windowoptionvalues-menuborderstyle"},{"id":"tmux.WindowOptionValues.MenuSelectedStyle","name":"MenuSelectedStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MenuSelectedStyle returns materialized \"menu-selected-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.4; set it with [Window.SetMenuSelectedStyle] or [GlobalWindowScope.SetMenuSelectedStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2639,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MenuSelectedStyle","product":"core","slug":"tmux-windowoptionvalues-menuselectedstyle"},{"id":"tmux.WindowOptionValues.MenuStyle","name":"MenuStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MenuStyle returns materialized \"menu-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.4; set it with [Window.SetMenuStyle] or [GlobalWindowScope.SetMenuStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2644,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MenuStyle","product":"core","slug":"tmux-windowoptionvalues-menustyle"},{"id":"tmux.WindowOptionValues.ModeKeys","name":"ModeKeys","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[ModeKeys]"}],"doc":{"summary":"ModeKeys returns materialized \"mode-keys\" as [OptionValue] with value type OptionValue[ModeKeys] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"emacs\", \"vi\"); set it with [Window.SetModeKeys] or [GlobalWindowScope.SetModeKeys]."},"source":{"file":"tmux/option_generated.go","line":2648,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.ModeKeys","product":"core","slug":"tmux-windowoptionvalues-modekeys"},{"id":"tmux.WindowOptionValues.ModeStyle","name":"ModeStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"ModeStyle returns materialized \"mode-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetModeStyle] or [GlobalWindowScope.SetModeStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2653,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.ModeStyle","product":"core","slug":"tmux-windowoptionvalues-modestyle"},{"id":"tmux.WindowOptionValues.MonitorActivity","name":"MonitorActivity","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"MonitorActivity returns materialized \"monitor-activity\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetMonitorActivity] or [GlobalWindowScope.SetMonitorActivity]."},"source":{"file":"tmux/option_generated.go","line":2657,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MonitorActivity","product":"core","slug":"tmux-windowoptionvalues-monitoractivity"},{"id":"tmux.WindowOptionValues.MonitorBell","name":"MonitorBell","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"MonitorBell returns materialized \"monitor-bell\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetMonitorBell] or [GlobalWindowScope.SetMonitorBell]."},"source":{"file":"tmux/option_generated.go","line":2661,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MonitorBell","product":"core","slug":"tmux-windowoptionvalues-monitorbell"},{"id":"tmux.WindowOptionValues.MonitorSilence","name":"MonitorSilence","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"MonitorSilence returns materialized \"monitor-silence\" as [OptionValue] with value type OptionValue[int64] from window option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Window.SetMonitorSilence] or [GlobalWindowScope.SetMonitorSilence]."},"source":{"file":"tmux/option_generated.go","line":2665,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.MonitorSilence","product":"core","slug":"tmux-windowoptionvalues-monitorsilence"},{"id":"tmux.WindowOptionValues.OtherPaneHeight","name":"OtherPaneHeight","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"OtherPaneHeight returns materialized \"other-pane-height\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetOtherPaneHeight] or [GlobalWindowScope.SetOtherPaneHeight]."},"source":{"file":"tmux/option_generated.go","line":2669,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.OtherPaneHeight","product":"core","slug":"tmux-windowoptionvalues-otherpaneheight"},{"id":"tmux.WindowOptionValues.OtherPaneWidth","name":"OtherPaneWidth","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"OtherPaneWidth returns materialized \"other-pane-width\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetOtherPaneWidth] or [GlobalWindowScope.SetOtherPaneWidth]."},"source":{"file":"tmux/option_generated.go","line":2673,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.OtherPaneWidth","product":"core","slug":"tmux-windowoptionvalues-otherpanewidth"},{"id":"tmux.WindowOptionValues.PaneActiveBorderStyle","name":"PaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneActiveBorderStyle returns materialized \"pane-active-border-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; STRING since tmux 3.7; set it with [Window.SetPaneActiveBorderStyle] or [GlobalWindowScope.SetPaneActiveBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2678,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneActiveBorderStyle","product":"core","slug":"tmux-windowoptionvalues-paneactiveborderstyle"},{"id":"tmux.WindowOptionValues.PaneBaseIndex","name":"PaneBaseIndex","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"PaneBaseIndex returns materialized \"pane-base-index\" as [OptionValue] with value type OptionValue[int64] from window option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Window.SetPaneBaseIndex] or [GlobalWindowScope.SetPaneBaseIndex]."},"source":{"file":"tmux/option_generated.go","line":2684,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneBaseIndex","product":"core","slug":"tmux-windowoptionvalues-panebaseindex"},{"id":"tmux.WindowOptionValues.PaneBorderFormat","name":"PaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneBorderFormat returns materialized \"pane-border-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; STRING since tmux 3.3; set it with [Window.SetPaneBorderFormat] or [GlobalWindowScope.SetPaneBorderFormat]."},"source":{"file":"tmux/option_generated.go","line":2688,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneBorderFormat","product":"core","slug":"tmux-windowoptionvalues-paneborderformat"},{"id":"tmux.WindowOptionValues.PaneBorderIndicators","name":"PaneBorderIndicators","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneBorderIndicators]"}],"doc":{"summary":"PaneBorderIndicators returns materialized \"pane-border-indicators\" as [OptionValue] with value type OptionValue[PaneBorderIndicators] from window option values; it does not query tmux. Available as CHOICE since tmux 3.3 (choices: \"off\", \"colour\", \"arrows\", \"both\"); set it with [Window.SetPaneBorderIndicators] or [GlobalWindowScope.SetPaneBorderIndicators]."},"source":{"file":"tmux/option_generated.go","line":2692,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneBorderIndicators","product":"core","slug":"tmux-windowoptionvalues-paneborderindicators"},{"id":"tmux.WindowOptionValues.PaneBorderLines","name":"PaneBorderLines","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneBorderLines]"}],"doc":{"summary":"PaneBorderLines returns materialized \"pane-border-lines\" as [OptionValue] with value type OptionValue[PaneBorderLines] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"single\", \"double\", \"heavy\", \"simple\", \"number\"); CHOICE since tmux 3.6 (choices: \"single\", \"double\", \"heavy\", \"simple\", \"number\", \"spaces\"); set it with [Window.SetPaneBorderLines] or [GlobalWindowScope.SetPaneBorderLines]."},"source":{"file":"tmux/option_generated.go","line":2698,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneBorderLines","product":"core","slug":"tmux-windowoptionvalues-paneborderlines"},{"id":"tmux.WindowOptionValues.PaneBorderStatus","name":"PaneBorderStatus","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneBorderStatus]"}],"doc":{"summary":"PaneBorderStatus returns materialized \"pane-border-status\" as [OptionValue] with value type OptionValue[PaneBorderStatus] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"top\", \"bottom\"); set it with [Window.SetPaneBorderStatus] or [GlobalWindowScope.SetPaneBorderStatus]."},"source":{"file":"tmux/option_generated.go","line":2702,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneBorderStatus","product":"core","slug":"tmux-windowoptionvalues-paneborderstatus"},{"id":"tmux.WindowOptionValues.PaneBorderStyle","name":"PaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneBorderStyle returns materialized \"pane-border-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; STRING since tmux 3.7; set it with [Window.SetPaneBorderStyle] or [GlobalWindowScope.SetPaneBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2709,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneBorderStyle","product":"core","slug":"tmux-windowoptionvalues-paneborderstyle"},{"id":"tmux.WindowOptionValues.PaneColours","name":"PaneColours","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneColours returns materialized \"pane-colours\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window option values; it does not query tmux. Available as COLOUR since tmux 3.3; set it with [Window.SetPaneColours] or [GlobalWindowScope.SetPaneColours]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":2714,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneColours","product":"core","slug":"tmux-windowoptionvalues-panecolours"},{"id":"tmux.WindowOptionValues.PaneScrollbars","name":"PaneScrollbars","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneScrollbars]"}],"doc":{"summary":"PaneScrollbars returns materialized \"pane-scrollbars\" as [OptionValue] with value type OptionValue[PaneScrollbars] from window option values; it does not query tmux. Available as CHOICE since tmux 3.6 (choices: \"off\", \"modal\", \"on\"); set it with [Window.SetPaneScrollbars] or [GlobalWindowScope.SetPaneScrollbars]."},"source":{"file":"tmux/option_generated.go","line":2718,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneScrollbars","product":"core","slug":"tmux-windowoptionvalues-panescrollbars"},{"id":"tmux.WindowOptionValues.PaneScrollbarsPosition","name":"PaneScrollbarsPosition","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneScrollbarsPosition]"}],"doc":{"summary":"PaneScrollbarsPosition returns materialized \"pane-scrollbars-position\" as [OptionValue] with value type OptionValue[PaneScrollbarsPosition] from window option values; it does not query tmux. Available as CHOICE since tmux 3.6 (choices: \"right\", \"left\"); set it with [Window.SetPaneScrollbarsPosition] or [GlobalWindowScope.SetPaneScrollbarsPosition]."},"source":{"file":"tmux/option_generated.go","line":2722,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneScrollbarsPosition","product":"core","slug":"tmux-windowoptionvalues-panescrollbarsposition"},{"id":"tmux.WindowOptionValues.PaneScrollbarsStyle","name":"PaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneScrollbarsStyle returns materialized \"pane-scrollbars-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetPaneScrollbarsStyle] or [GlobalWindowScope.SetPaneScrollbarsStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2729,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneScrollbarsStyle","product":"core","slug":"tmux-windowoptionvalues-panescrollbarsstyle"},{"id":"tmux.WindowOptionValues.PaneStatusCurrentStyle","name":"PaneStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneStatusCurrentStyle returns materialized \"pane-status-current-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetPaneStatusCurrentStyle] or [GlobalWindowScope.SetPaneStatusCurrentStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2734,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneStatusCurrentStyle","product":"core","slug":"tmux-windowoptionvalues-panestatuscurrentstyle"},{"id":"tmux.WindowOptionValues.PaneStatusStyle","name":"PaneStatusStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneStatusStyle returns materialized \"pane-status-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetPaneStatusStyle] or [GlobalWindowScope.SetPaneStatusStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2741,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PaneStatusStyle","product":"core","slug":"tmux-windowoptionvalues-panestatusstyle"},{"id":"tmux.WindowOptionValues.PopupBorderLines","name":"PopupBorderLines","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PopupBorderLines]"}],"doc":{"summary":"PopupBorderLines returns materialized \"popup-border-lines\" as [OptionValue] with value type OptionValue[PopupBorderLines] from window option values; it does not query tmux. Available as CHOICE since tmux 3.3 (choices: \"single\", \"double\", \"heavy\", \"simple\", \"rounded\", \"padded\", \"none\"); set it with [Window.SetPopupBorderLines] or [GlobalWindowScope.SetPopupBorderLines]."},"source":{"file":"tmux/option_generated.go","line":2745,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PopupBorderLines","product":"core","slug":"tmux-windowoptionvalues-popupborderlines"},{"id":"tmux.WindowOptionValues.PopupBorderStyle","name":"PopupBorderStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PopupBorderStyle returns materialized \"popup-border-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Window.SetPopupBorderStyle] or [GlobalWindowScope.SetPopupBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2752,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PopupBorderStyle","product":"core","slug":"tmux-windowoptionvalues-popupborderstyle"},{"id":"tmux.WindowOptionValues.PopupStyle","name":"PopupStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PopupStyle returns materialized \"popup-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Window.SetPopupStyle] or [GlobalWindowScope.SetPopupStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2757,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.PopupStyle","product":"core","slug":"tmux-windowoptionvalues-popupstyle"},{"id":"tmux.WindowOptionValues.RemainOnExit","name":"RemainOnExit","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[RemainOnExit]"}],"doc":{"summary":"RemainOnExit returns materialized \"remain-on-exit\" as [OptionValue] with value type OptionValue[RemainOnExit] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"failed\"); CHOICE since tmux 3.7 (choices: \"off\", \"on\", \"failed\", \"key\"); set it with [Window.SetRemainOnExit] or [GlobalWindowScope.SetRemainOnExit]."},"source":{"file":"tmux/option_generated.go","line":2761,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.RemainOnExit","product":"core","slug":"tmux-windowoptionvalues-remainonexit"},{"id":"tmux.WindowOptionValues.RemainOnExitFormat","name":"RemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"RemainOnExitFormat returns materialized \"remain-on-exit-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Window.SetRemainOnExitFormat] or [GlobalWindowScope.SetRemainOnExitFormat]."},"source":{"file":"tmux/option_generated.go","line":2765,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.RemainOnExitFormat","product":"core","slug":"tmux-windowoptionvalues-remainonexitformat"},{"id":"tmux.WindowOptionValues.ScrollOnClear","name":"ScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"ScrollOnClear returns materialized \"scroll-on-clear\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.3; set it with [Window.SetScrollOnClear] or [GlobalWindowScope.SetScrollOnClear]."},"source":{"file":"tmux/option_generated.go","line":2769,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.ScrollOnClear","product":"core","slug":"tmux-windowoptionvalues-scrollonclear"},{"id":"tmux.WindowOptionValues.SessionStatusCurrentStyle","name":"SessionStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"SessionStatusCurrentStyle returns materialized \"session-status-current-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetSessionStatusCurrentStyle] or [GlobalWindowScope.SetSessionStatusCurrentStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2774,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.SessionStatusCurrentStyle","product":"core","slug":"tmux-windowoptionvalues-sessionstatuscurrentstyle"},{"id":"tmux.WindowOptionValues.SessionStatusStyle","name":"SessionStatusStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"SessionStatusStyle returns materialized \"session-status-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetSessionStatusStyle] or [GlobalWindowScope.SetSessionStatusStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2781,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.SessionStatusStyle","product":"core","slug":"tmux-windowoptionvalues-sessionstatusstyle"},{"id":"tmux.WindowOptionValues.SynchronizePanes","name":"SynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"SynchronizePanes returns materialized \"synchronize-panes\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetSynchronizePanes] or [GlobalWindowScope.SetSynchronizePanes]."},"source":{"file":"tmux/option_generated.go","line":2785,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.SynchronizePanes","product":"core","slug":"tmux-windowoptionvalues-synchronizepanes"},{"id":"tmux.WindowOptionValues.TiledLayoutMaxColumns","name":"TiledLayoutMaxColumns","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"TiledLayoutMaxColumns returns materialized \"tiled-layout-max-columns\" as [OptionValue] with value type OptionValue[int64] from window option values; it does not query tmux. Available as NUMBER since tmux 3.6; set it with [Window.SetTiledLayoutMaxColumns] or [GlobalWindowScope.SetTiledLayoutMaxColumns]."},"source":{"file":"tmux/option_generated.go","line":2789,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.TiledLayoutMaxColumns","product":"core","slug":"tmux-windowoptionvalues-tiledlayoutmaxcolumns"},{"id":"tmux.WindowOptionValues.TreeModePreviewFormat","name":"TreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"TreeModePreviewFormat returns materialized \"tree-mode-preview-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetTreeModePreviewFormat] or [GlobalWindowScope.SetTreeModePreviewFormat]."},"source":{"file":"tmux/option_generated.go","line":2795,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.TreeModePreviewFormat","product":"core","slug":"tmux-windowoptionvalues-treemodepreviewformat"},{"id":"tmux.WindowOptionValues.TreeModePreviewStyle","name":"TreeModePreviewStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"TreeModePreviewStyle returns materialized \"tree-mode-preview-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetTreeModePreviewStyle] or [GlobalWindowScope.SetTreeModePreviewStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2802,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.TreeModePreviewStyle","product":"core","slug":"tmux-windowoptionvalues-treemodepreviewstyle"},{"id":"tmux.WindowOptionValues.WindowActiveStyle","name":"WindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowActiveStyle returns materialized \"window-active-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowActiveStyle] or [GlobalWindowScope.SetWindowActiveStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2807,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowActiveStyle","product":"core","slug":"tmux-windowoptionvalues-windowactivestyle"},{"id":"tmux.WindowOptionValues.WindowPaneCurrentStatusFormat","name":"WindowPaneCurrentStatusFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowPaneCurrentStatusFormat returns materialized \"window-pane-current-status-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetWindowPaneCurrentStatusFormat] or [GlobalWindowScope.SetWindowPaneCurrentStatusFormat]."},"source":{"file":"tmux/option_generated.go","line":2811,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowPaneCurrentStatusFormat","product":"core","slug":"tmux-windowoptionvalues-windowpanecurrentstatusformat"},{"id":"tmux.WindowOptionValues.WindowPaneStatusFormat","name":"WindowPaneStatusFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowPaneStatusFormat returns materialized \"window-pane-status-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetWindowPaneStatusFormat] or [GlobalWindowScope.SetWindowPaneStatusFormat]."},"source":{"file":"tmux/option_generated.go","line":2817,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowPaneStatusFormat","product":"core","slug":"tmux-windowoptionvalues-windowpanestatusformat"},{"id":"tmux.WindowOptionValues.WindowSize","name":"WindowSize","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[WindowSize]"}],"doc":{"summary":"WindowSize returns materialized \"window-size\" as [OptionValue] with value type OptionValue[WindowSize] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"largest\", \"smallest\", \"manual\", \"latest\"); set it with [Window.SetWindowSize] or [GlobalWindowScope.SetWindowSize]."},"source":{"file":"tmux/option_generated.go","line":2823,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowSize","product":"core","slug":"tmux-windowoptionvalues-windowsize"},{"id":"tmux.WindowOptionValues.WindowStatusActivityStyle","name":"WindowStatusActivityStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusActivityStyle returns materialized \"window-status-activity-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusActivityStyle] or [GlobalWindowScope.SetWindowStatusActivityStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2828,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStatusActivityStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatusactivitystyle"},{"id":"tmux.WindowOptionValues.WindowStatusBellStyle","name":"WindowStatusBellStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusBellStyle returns materialized \"window-status-bell-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusBellStyle] or [GlobalWindowScope.SetWindowStatusBellStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2835,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStatusBellStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatusbellstyle"},{"id":"tmux.WindowOptionValues.WindowStatusCurrentFormat","name":"WindowStatusCurrentFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusCurrentFormat returns materialized \"window-status-current-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusCurrentFormat] or [GlobalWindowScope.SetWindowStatusCurrentFormat]."},"source":{"file":"tmux/option_generated.go","line":2841,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStatusCurrentFormat","product":"core","slug":"tmux-windowoptionvalues-windowstatuscurrentformat"},{"id":"tmux.WindowOptionValues.WindowStatusCurrentStyle","name":"WindowStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusCurrentStyle returns materialized \"window-status-current-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusCurrentStyle] or [GlobalWindowScope.SetWindowStatusCurrentStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2848,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStatusCurrentStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatuscurrentstyle"},{"id":"tmux.WindowOptionValues.WindowStatusFormat","name":"WindowStatusFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusFormat returns materialized \"window-status-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusFormat] or [GlobalWindowScope.SetWindowStatusFormat]."},"source":{"file":"tmux/option_generated.go","line":2854,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStatusFormat","product":"core","slug":"tmux-windowoptionvalues-windowstatusformat"},{"id":"tmux.WindowOptionValues.WindowStatusLastStyle","name":"WindowStatusLastStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusLastStyle returns materialized \"window-status-last-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusLastStyle] or [GlobalWindowScope.SetWindowStatusLastStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2859,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStatusLastStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatuslaststyle"},{"id":"tmux.WindowOptionValues.WindowStatusSeparator","name":"WindowStatusSeparator","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusSeparator returns materialized \"window-status-separator\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusSeparator] or [GlobalWindowScope.SetWindowStatusSeparator]."},"source":{"file":"tmux/option_generated.go","line":2865,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStatusSeparator","product":"core","slug":"tmux-windowoptionvalues-windowstatusseparator"},{"id":"tmux.WindowOptionValues.WindowStatusStyle","name":"WindowStatusStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusStyle returns materialized \"window-status-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusStyle] or [GlobalWindowScope.SetWindowStatusStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2872,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStatusStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatusstyle"},{"id":"tmux.WindowOptionValues.WindowStyle","name":"WindowStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStyle returns materialized \"window-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStyle] or [GlobalWindowScope.SetWindowStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2877,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WindowStyle","product":"core","slug":"tmux-windowoptionvalues-windowstyle"},{"id":"tmux.WindowOptionValues.WrapSearch","name":"WrapSearch","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"WrapSearch returns materialized \"wrap-search\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetWrapSearch] or [GlobalWindowScope.SetWrapSearch]."},"source":{"file":"tmux/option_generated.go","line":2881,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.WrapSearch","product":"core","slug":"tmux-windowoptionvalues-wrapsearch"},{"id":"tmux.WindowOptionValues.XTermKeys","name":"XTermKeys","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"XTermKeys returns materialized \"xterm-keys\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetXTermKeys] or [GlobalWindowScope.SetXTermKeys]."},"source":{"file":"tmux/option_generated.go","line":2885,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowOptionValues.XTermKeys","product":"core","slug":"tmux-windowoptionvalues-xtermkeys"},{"id":"tmux.PaneOptionValues","name":"PaneOptionValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneOptionValues is an immutable materialized view of known pane option values; its zero value is empty and it does not refresh. Obtain it with [Pane.Options]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Pane.RawOption] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":3047,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues","product":"core","slug":"tmux-paneoptionvalues"},{"id":"tmux.PaneOptionValues.AllowPassthrough","name":"AllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[AllowPassthrough]"}],"doc":{"summary":"AllowPassthrough returns materialized \"allow-passthrough\" as [OptionValue] with value type OptionValue[AllowPassthrough] from pane option values; it does not query tmux. Available as FLAG since tmux 3.3; CHOICE since tmux 3.4 (choices: \"off\", \"on\", \"all\"); set it with [Pane.SetAllowPassthrough]."},"source":{"file":"tmux/option_generated.go","line":3071,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.AllowPassthrough","product":"core","slug":"tmux-paneoptionvalues-allowpassthrough"},{"id":"tmux.PaneOptionValues.AllowRename","name":"AllowRename","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AllowRename returns materialized \"allow-rename\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Pane.SetAllowRename]."},"source":{"file":"tmux/option_generated.go","line":3075,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.AllowRename","product":"core","slug":"tmux-paneoptionvalues-allowrename"},{"id":"tmux.PaneOptionValues.AllowSetTitle","name":"AllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AllowSetTitle returns materialized \"allow-set-title\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.5; set it with [Pane.SetAllowSetTitle]."},"source":{"file":"tmux/option_generated.go","line":3079,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.AllowSetTitle","product":"core","slug":"tmux-paneoptionvalues-allowsettitle"},{"id":"tmux.PaneOptionValues.AlternateScreen","name":"AlternateScreen","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AlternateScreen returns materialized \"alternate-screen\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Pane.SetAlternateScreen]."},"source":{"file":"tmux/option_generated.go","line":3083,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.AlternateScreen","product":"core","slug":"tmux-paneoptionvalues-alternatescreen"},{"id":"tmux.PaneOptionValues.CopyModePositionFormat","name":"CopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModePositionFormat returns materialized \"copy-mode-position-format\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Pane.SetCopyModePositionFormat]."},"source":{"file":"tmux/option_generated.go","line":3087,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.CopyModePositionFormat","product":"core","slug":"tmux-paneoptionvalues-copymodepositionformat"},{"id":"tmux.PaneOptionValues.CursorColour","name":"CursorColour","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CursorColour returns materialized \"cursor-colour\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as COLOUR since tmux 3.3; set it with [Pane.SetCursorColour]."},"source":{"file":"tmux/option_generated.go","line":3093,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.CursorColour","product":"core","slug":"tmux-paneoptionvalues-cursorcolour"},{"id":"tmux.PaneOptionValues.CursorStyle","name":"CursorStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[CursorStyle]"}],"doc":{"summary":"CursorStyle returns materialized \"cursor-style\" as [OptionValue] with value type OptionValue[CursorStyle] from pane option values; it does not query tmux. Available as CHOICE since tmux 3.3 (choices: \"default\", \"blinking-block\", \"block\", \"blinking-underline\", \"underline\", \"blinking-bar\", \"bar\"); set it with [Pane.SetCursorStyle]."},"source":{"file":"tmux/option_generated.go","line":3097,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.CursorStyle","product":"core","slug":"tmux-paneoptionvalues-cursorstyle"},{"id":"tmux.PaneOptionValues.PaneActiveBorderStyle","name":"PaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneActiveBorderStyle returns materialized \"pane-active-border-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Pane.SetPaneActiveBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3102,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.PaneActiveBorderStyle","product":"core","slug":"tmux-paneoptionvalues-paneactiveborderstyle"},{"id":"tmux.PaneOptionValues.PaneBorderFormat","name":"PaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneBorderFormat returns materialized \"pane-border-format\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Pane.SetPaneBorderFormat]."},"source":{"file":"tmux/option_generated.go","line":3106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.PaneBorderFormat","product":"core","slug":"tmux-paneoptionvalues-paneborderformat"},{"id":"tmux.PaneOptionValues.PaneBorderStyle","name":"PaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneBorderStyle returns materialized \"pane-border-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Pane.SetPaneBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.PaneBorderStyle","product":"core","slug":"tmux-paneoptionvalues-paneborderstyle"},{"id":"tmux.PaneOptionValues.PaneColours","name":"PaneColours","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneColours returns materialized \"pane-colours\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane option values; it does not query tmux. Available as COLOUR since tmux 3.3; set it with [Pane.SetPaneColours]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3116,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.PaneColours","product":"core","slug":"tmux-paneoptionvalues-panecolours"},{"id":"tmux.PaneOptionValues.PaneScrollbarsStyle","name":"PaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneScrollbarsStyle returns materialized \"pane-scrollbars-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Pane.SetPaneScrollbarsStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3121,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.PaneScrollbarsStyle","product":"core","slug":"tmux-paneoptionvalues-panescrollbarsstyle"},{"id":"tmux.PaneOptionValues.RemainOnExit","name":"RemainOnExit","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[RemainOnExit]"}],"doc":{"summary":"RemainOnExit returns materialized \"remain-on-exit\" as [OptionValue] with value type OptionValue[RemainOnExit] from pane option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"failed\"); CHOICE since tmux 3.7 (choices: \"off\", \"on\", \"failed\", \"key\"); set it with [Pane.SetRemainOnExit]."},"source":{"file":"tmux/option_generated.go","line":3125,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.RemainOnExit","product":"core","slug":"tmux-paneoptionvalues-remainonexit"},{"id":"tmux.PaneOptionValues.RemainOnExitFormat","name":"RemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"RemainOnExitFormat returns materialized \"remain-on-exit-format\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Pane.SetRemainOnExitFormat]."},"source":{"file":"tmux/option_generated.go","line":3129,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.RemainOnExitFormat","product":"core","slug":"tmux-paneoptionvalues-remainonexitformat"},{"id":"tmux.PaneOptionValues.ScrollOnClear","name":"ScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"ScrollOnClear returns materialized \"scroll-on-clear\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.3; set it with [Pane.SetScrollOnClear]."},"source":{"file":"tmux/option_generated.go","line":3133,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.ScrollOnClear","product":"core","slug":"tmux-paneoptionvalues-scrollonclear"},{"id":"tmux.PaneOptionValues.SynchronizePanes","name":"SynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"SynchronizePanes returns materialized \"synchronize-panes\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Pane.SetSynchronizePanes]."},"source":{"file":"tmux/option_generated.go","line":3137,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.SynchronizePanes","product":"core","slug":"tmux-paneoptionvalues-synchronizepanes"},{"id":"tmux.PaneOptionValues.TreeModePreviewFormat","name":"TreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"TreeModePreviewFormat returns materialized \"tree-mode-preview-format\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Pane.SetTreeModePreviewFormat]."},"source":{"file":"tmux/option_generated.go","line":3141,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.TreeModePreviewFormat","product":"core","slug":"tmux-paneoptionvalues-treemodepreviewformat"},{"id":"tmux.PaneOptionValues.WindowActiveStyle","name":"WindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowActiveStyle returns materialized \"window-active-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Pane.SetWindowActiveStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3146,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.WindowActiveStyle","product":"core","slug":"tmux-paneoptionvalues-windowactivestyle"},{"id":"tmux.PaneOptionValues.WindowStyle","name":"WindowStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStyle returns materialized \"window-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Pane.SetWindowStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3151,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneOptionValues.WindowStyle","product":"core","slug":"tmux-paneoptionvalues-windowstyle"},{"id":"tmux.ServerHookValues","name":"ServerHookValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerHookValues is an immutable materialized view of known global session-scope hook values; its zero value is empty and it does not refresh. Obtain it with [GlobalSessionScope.Hooks]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [GlobalSessionScope.RawHook] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":3203,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues","product":"core","slug":"tmux-serverhookvalues"},{"id":"tmux.ServerHookValues.AfterBindKey","name":"AfterBindKey","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterBindKey returns materialized \"after-bind-key\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3266,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterBindKey","product":"core","slug":"tmux-serverhookvalues-afterbindkey"},{"id":"tmux.ServerHookValues.AfterCapturePane","name":"AfterCapturePane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterCapturePane returns materialized \"after-capture-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3271,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterCapturePane","product":"core","slug":"tmux-serverhookvalues-aftercapturepane"},{"id":"tmux.ServerHookValues.AfterCopyMode","name":"AfterCopyMode","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterCopyMode returns materialized \"after-copy-mode\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3278,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterCopyMode","product":"core","slug":"tmux-serverhookvalues-aftercopymode"},{"id":"tmux.ServerHookValues.AfterDisplayMessage","name":"AfterDisplayMessage","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterDisplayMessage returns materialized \"after-display-message\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3283,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterDisplayMessage","product":"core","slug":"tmux-serverhookvalues-afterdisplaymessage"},{"id":"tmux.ServerHookValues.AfterDisplayPanes","name":"AfterDisplayPanes","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterDisplayPanes returns materialized \"after-display-panes\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3290,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterDisplayPanes","product":"core","slug":"tmux-serverhookvalues-afterdisplaypanes"},{"id":"tmux.ServerHookValues.AfterKillPane","name":"AfterKillPane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterKillPane returns materialized \"after-kill-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3297,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterKillPane","product":"core","slug":"tmux-serverhookvalues-afterkillpane"},{"id":"tmux.ServerHookValues.AfterListBuffers","name":"AfterListBuffers","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListBuffers returns materialized \"after-list-buffers\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3302,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterListBuffers","product":"core","slug":"tmux-serverhookvalues-afterlistbuffers"},{"id":"tmux.ServerHookValues.AfterListClients","name":"AfterListClients","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListClients returns materialized \"after-list-clients\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3309,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterListClients","product":"core","slug":"tmux-serverhookvalues-afterlistclients"},{"id":"tmux.ServerHookValues.AfterListKeys","name":"AfterListKeys","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListKeys returns materialized \"after-list-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3316,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterListKeys","product":"core","slug":"tmux-serverhookvalues-afterlistkeys"},{"id":"tmux.ServerHookValues.AfterListPanes","name":"AfterListPanes","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListPanes returns materialized \"after-list-panes\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3321,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterListPanes","product":"core","slug":"tmux-serverhookvalues-afterlistpanes"},{"id":"tmux.ServerHookValues.AfterListSessions","name":"AfterListSessions","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListSessions returns materialized \"after-list-sessions\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3326,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterListSessions","product":"core","slug":"tmux-serverhookvalues-afterlistsessions"},{"id":"tmux.ServerHookValues.AfterListWindows","name":"AfterListWindows","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListWindows returns materialized \"after-list-windows\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3333,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterListWindows","product":"core","slug":"tmux-serverhookvalues-afterlistwindows"},{"id":"tmux.ServerHookValues.AfterLoadBuffer","name":"AfterLoadBuffer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterLoadBuffer returns materialized \"after-load-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3340,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterLoadBuffer","product":"core","slug":"tmux-serverhookvalues-afterloadbuffer"},{"id":"tmux.ServerHookValues.AfterLockServer","name":"AfterLockServer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterLockServer returns materialized \"after-lock-server\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3347,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterLockServer","product":"core","slug":"tmux-serverhookvalues-afterlockserver"},{"id":"tmux.ServerHookValues.AfterNewSession","name":"AfterNewSession","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterNewSession returns materialized \"after-new-session\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3354,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterNewSession","product":"core","slug":"tmux-serverhookvalues-afternewsession"},{"id":"tmux.ServerHookValues.AfterNewWindow","name":"AfterNewWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterNewWindow returns materialized \"after-new-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3361,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterNewWindow","product":"core","slug":"tmux-serverhookvalues-afternewwindow"},{"id":"tmux.ServerHookValues.AfterPasteBuffer","name":"AfterPasteBuffer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterPasteBuffer returns materialized \"after-paste-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3366,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterPasteBuffer","product":"core","slug":"tmux-serverhookvalues-afterpastebuffer"},{"id":"tmux.ServerHookValues.AfterPipePane","name":"AfterPipePane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterPipePane returns materialized \"after-pipe-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3373,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterPipePane","product":"core","slug":"tmux-serverhookvalues-afterpipepane"},{"id":"tmux.ServerHookValues.AfterQueue","name":"AfterQueue","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterQueue returns materialized \"after-queue\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3378,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterQueue","product":"core","slug":"tmux-serverhookvalues-afterqueue"},{"id":"tmux.ServerHookValues.AfterRefreshClient","name":"AfterRefreshClient","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRefreshClient returns materialized \"after-refresh-client\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3383,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterRefreshClient","product":"core","slug":"tmux-serverhookvalues-afterrefreshclient"},{"id":"tmux.ServerHookValues.AfterRenameSession","name":"AfterRenameSession","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRenameSession returns materialized \"after-rename-session\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3390,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterRenameSession","product":"core","slug":"tmux-serverhookvalues-afterrenamesession"},{"id":"tmux.ServerHookValues.AfterRenameWindow","name":"AfterRenameWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRenameWindow returns materialized \"after-rename-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3397,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterRenameWindow","product":"core","slug":"tmux-serverhookvalues-afterrenamewindow"},{"id":"tmux.ServerHookValues.AfterResizePane","name":"AfterResizePane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterResizePane returns materialized \"after-resize-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3404,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterResizePane","product":"core","slug":"tmux-serverhookvalues-afterresizepane"},{"id":"tmux.ServerHookValues.AfterResizeWindow","name":"AfterResizeWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterResizeWindow returns materialized \"after-resize-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3411,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterResizeWindow","product":"core","slug":"tmux-serverhookvalues-afterresizewindow"},{"id":"tmux.ServerHookValues.AfterSaveBuffer","name":"AfterSaveBuffer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSaveBuffer returns materialized \"after-save-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3418,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSaveBuffer","product":"core","slug":"tmux-serverhookvalues-aftersavebuffer"},{"id":"tmux.ServerHookValues.AfterSelectLayout","name":"AfterSelectLayout","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectLayout returns materialized \"after-select-layout\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3425,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSelectLayout","product":"core","slug":"tmux-serverhookvalues-afterselectlayout"},{"id":"tmux.ServerHookValues.AfterSelectPane","name":"AfterSelectPane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectPane returns materialized \"after-select-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3432,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSelectPane","product":"core","slug":"tmux-serverhookvalues-afterselectpane"},{"id":"tmux.ServerHookValues.AfterSelectWindow","name":"AfterSelectWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectWindow returns materialized \"after-select-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3439,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSelectWindow","product":"core","slug":"tmux-serverhookvalues-afterselectwindow"},{"id":"tmux.ServerHookValues.AfterSendKeys","name":"AfterSendKeys","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSendKeys returns materialized \"after-send-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3446,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSendKeys","product":"core","slug":"tmux-serverhookvalues-aftersendkeys"},{"id":"tmux.ServerHookValues.AfterSetBuffer","name":"AfterSetBuffer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetBuffer returns materialized \"after-set-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3451,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSetBuffer","product":"core","slug":"tmux-serverhookvalues-aftersetbuffer"},{"id":"tmux.ServerHookValues.AfterSetEnvironment","name":"AfterSetEnvironment","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetEnvironment returns materialized \"after-set-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3456,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSetEnvironment","product":"core","slug":"tmux-serverhookvalues-aftersetenvironment"},{"id":"tmux.ServerHookValues.AfterSetHook","name":"AfterSetHook","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetHook returns materialized \"after-set-hook\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3463,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSetHook","product":"core","slug":"tmux-serverhookvalues-aftersethook"},{"id":"tmux.ServerHookValues.AfterSetOption","name":"AfterSetOption","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetOption returns materialized \"after-set-option\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3468,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSetOption","product":"core","slug":"tmux-serverhookvalues-aftersetoption"},{"id":"tmux.ServerHookValues.AfterShowEnvironment","name":"AfterShowEnvironment","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowEnvironment returns materialized \"after-show-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3473,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterShowEnvironment","product":"core","slug":"tmux-serverhookvalues-aftershowenvironment"},{"id":"tmux.ServerHookValues.AfterShowMessages","name":"AfterShowMessages","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowMessages returns materialized \"after-show-messages\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3480,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterShowMessages","product":"core","slug":"tmux-serverhookvalues-aftershowmessages"},{"id":"tmux.ServerHookValues.AfterShowOptions","name":"AfterShowOptions","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowOptions returns materialized \"after-show-options\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3487,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterShowOptions","product":"core","slug":"tmux-serverhookvalues-aftershowoptions"},{"id":"tmux.ServerHookValues.AfterSplitWindow","name":"AfterSplitWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSplitWindow returns materialized \"after-split-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3494,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterSplitWindow","product":"core","slug":"tmux-serverhookvalues-aftersplitwindow"},{"id":"tmux.ServerHookValues.AfterUnbindKey","name":"AfterUnbindKey","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterUnbindKey returns materialized \"after-unbind-key\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3501,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AfterUnbindKey","product":"core","slug":"tmux-serverhookvalues-afterunbindkey"},{"id":"tmux.ServerHookValues.AlertActivity","name":"AlertActivity","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertActivity returns materialized \"alert-activity\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3506,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AlertActivity","product":"core","slug":"tmux-serverhookvalues-alertactivity"},{"id":"tmux.ServerHookValues.AlertBell","name":"AlertBell","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertBell returns materialized \"alert-bell\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3511,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AlertBell","product":"core","slug":"tmux-serverhookvalues-alertbell"},{"id":"tmux.ServerHookValues.AlertSilence","name":"AlertSilence","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertSilence returns materialized \"alert-silence\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3516,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.AlertSilence","product":"core","slug":"tmux-serverhookvalues-alertsilence"},{"id":"tmux.ServerHookValues.ClientActive","name":"ClientActive","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientActive returns materialized \"client-active\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3521,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientActive","product":"core","slug":"tmux-serverhookvalues-clientactive"},{"id":"tmux.ServerHookValues.ClientAttached","name":"ClientAttached","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientAttached returns materialized \"client-attached\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3526,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientAttached","product":"core","slug":"tmux-serverhookvalues-clientattached"},{"id":"tmux.ServerHookValues.ClientDarkTheme","name":"ClientDarkTheme","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientDarkTheme returns materialized \"client-dark-theme\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.6. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3531,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientDarkTheme","product":"core","slug":"tmux-serverhookvalues-clientdarktheme"},{"id":"tmux.ServerHookValues.ClientDetached","name":"ClientDetached","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientDetached returns materialized \"client-detached\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3538,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientDetached","product":"core","slug":"tmux-serverhookvalues-clientdetached"},{"id":"tmux.ServerHookValues.ClientFocusIn","name":"ClientFocusIn","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientFocusIn returns materialized \"client-focus-in\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3543,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientFocusIn","product":"core","slug":"tmux-serverhookvalues-clientfocusin"},{"id":"tmux.ServerHookValues.ClientFocusOut","name":"ClientFocusOut","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientFocusOut returns materialized \"client-focus-out\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3548,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientFocusOut","product":"core","slug":"tmux-serverhookvalues-clientfocusout"},{"id":"tmux.ServerHookValues.ClientLightTheme","name":"ClientLightTheme","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientLightTheme returns materialized \"client-light-theme\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.6. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3553,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientLightTheme","product":"core","slug":"tmux-serverhookvalues-clientlighttheme"},{"id":"tmux.ServerHookValues.ClientResized","name":"ClientResized","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientResized returns materialized \"client-resized\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3560,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientResized","product":"core","slug":"tmux-serverhookvalues-clientresized"},{"id":"tmux.ServerHookValues.ClientSessionChanged","name":"ClientSessionChanged","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientSessionChanged returns materialized \"client-session-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3565,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.ClientSessionChanged","product":"core","slug":"tmux-serverhookvalues-clientsessionchanged"},{"id":"tmux.ServerHookValues.CommandError","name":"CommandError","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"CommandError returns materialized \"command-error\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.5. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3572,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.CommandError","product":"core","slug":"tmux-serverhookvalues-commanderror"},{"id":"tmux.ServerHookValues.SessionClosed","name":"SessionClosed","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionClosed returns materialized \"session-closed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3577,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.SessionClosed","product":"core","slug":"tmux-serverhookvalues-sessionclosed"},{"id":"tmux.ServerHookValues.SessionCreated","name":"SessionCreated","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionCreated returns materialized \"session-created\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3582,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.SessionCreated","product":"core","slug":"tmux-serverhookvalues-sessioncreated"},{"id":"tmux.ServerHookValues.SessionRenamed","name":"SessionRenamed","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionRenamed returns materialized \"session-renamed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3587,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.SessionRenamed","product":"core","slug":"tmux-serverhookvalues-sessionrenamed"},{"id":"tmux.ServerHookValues.SessionWindowChanged","name":"SessionWindowChanged","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionWindowChanged returns materialized \"session-window-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3592,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.SessionWindowChanged","product":"core","slug":"tmux-serverhookvalues-sessionwindowchanged"},{"id":"tmux.ServerHookValues.WindowLinked","name":"WindowLinked","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowLinked returns materialized \"window-linked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3599,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.WindowLinked","product":"core","slug":"tmux-serverhookvalues-windowlinked"},{"id":"tmux.ServerHookValues.WindowUnlinked","name":"WindowUnlinked","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowUnlinked returns materialized \"window-unlinked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3604,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerHookValues.WindowUnlinked","product":"core","slug":"tmux-serverhookvalues-windowunlinked"},{"id":"tmux.SessionHookValues","name":"SessionHookValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionHookValues is an immutable materialized view of known session hook values; its zero value is empty and it does not refresh. Obtain it with [Session.Hooks]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Session.RawHook] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":3732,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues","product":"core","slug":"tmux-sessionhookvalues"},{"id":"tmux.SessionHookValues.AfterBindKey","name":"AfterBindKey","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterBindKey returns materialized \"after-bind-key\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3795,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterBindKey","product":"core","slug":"tmux-sessionhookvalues-afterbindkey"},{"id":"tmux.SessionHookValues.AfterCapturePane","name":"AfterCapturePane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterCapturePane returns materialized \"after-capture-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3800,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterCapturePane","product":"core","slug":"tmux-sessionhookvalues-aftercapturepane"},{"id":"tmux.SessionHookValues.AfterCopyMode","name":"AfterCopyMode","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterCopyMode returns materialized \"after-copy-mode\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3807,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterCopyMode","product":"core","slug":"tmux-sessionhookvalues-aftercopymode"},{"id":"tmux.SessionHookValues.AfterDisplayMessage","name":"AfterDisplayMessage","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterDisplayMessage returns materialized \"after-display-message\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3812,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterDisplayMessage","product":"core","slug":"tmux-sessionhookvalues-afterdisplaymessage"},{"id":"tmux.SessionHookValues.AfterDisplayPanes","name":"AfterDisplayPanes","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterDisplayPanes returns materialized \"after-display-panes\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3819,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterDisplayPanes","product":"core","slug":"tmux-sessionhookvalues-afterdisplaypanes"},{"id":"tmux.SessionHookValues.AfterKillPane","name":"AfterKillPane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterKillPane returns materialized \"after-kill-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3826,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterKillPane","product":"core","slug":"tmux-sessionhookvalues-afterkillpane"},{"id":"tmux.SessionHookValues.AfterListBuffers","name":"AfterListBuffers","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListBuffers returns materialized \"after-list-buffers\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3831,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterListBuffers","product":"core","slug":"tmux-sessionhookvalues-afterlistbuffers"},{"id":"tmux.SessionHookValues.AfterListClients","name":"AfterListClients","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListClients returns materialized \"after-list-clients\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3838,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterListClients","product":"core","slug":"tmux-sessionhookvalues-afterlistclients"},{"id":"tmux.SessionHookValues.AfterListKeys","name":"AfterListKeys","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListKeys returns materialized \"after-list-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3845,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterListKeys","product":"core","slug":"tmux-sessionhookvalues-afterlistkeys"},{"id":"tmux.SessionHookValues.AfterListPanes","name":"AfterListPanes","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListPanes returns materialized \"after-list-panes\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3850,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterListPanes","product":"core","slug":"tmux-sessionhookvalues-afterlistpanes"},{"id":"tmux.SessionHookValues.AfterListSessions","name":"AfterListSessions","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListSessions returns materialized \"after-list-sessions\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3855,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterListSessions","product":"core","slug":"tmux-sessionhookvalues-afterlistsessions"},{"id":"tmux.SessionHookValues.AfterListWindows","name":"AfterListWindows","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListWindows returns materialized \"after-list-windows\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3862,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterListWindows","product":"core","slug":"tmux-sessionhookvalues-afterlistwindows"},{"id":"tmux.SessionHookValues.AfterLoadBuffer","name":"AfterLoadBuffer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterLoadBuffer returns materialized \"after-load-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3869,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterLoadBuffer","product":"core","slug":"tmux-sessionhookvalues-afterloadbuffer"},{"id":"tmux.SessionHookValues.AfterLockServer","name":"AfterLockServer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterLockServer returns materialized \"after-lock-server\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3876,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterLockServer","product":"core","slug":"tmux-sessionhookvalues-afterlockserver"},{"id":"tmux.SessionHookValues.AfterNewSession","name":"AfterNewSession","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterNewSession returns materialized \"after-new-session\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3883,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterNewSession","product":"core","slug":"tmux-sessionhookvalues-afternewsession"},{"id":"tmux.SessionHookValues.AfterNewWindow","name":"AfterNewWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterNewWindow returns materialized \"after-new-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3890,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterNewWindow","product":"core","slug":"tmux-sessionhookvalues-afternewwindow"},{"id":"tmux.SessionHookValues.AfterPasteBuffer","name":"AfterPasteBuffer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterPasteBuffer returns materialized \"after-paste-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3895,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterPasteBuffer","product":"core","slug":"tmux-sessionhookvalues-afterpastebuffer"},{"id":"tmux.SessionHookValues.AfterPipePane","name":"AfterPipePane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterPipePane returns materialized \"after-pipe-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3902,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterPipePane","product":"core","slug":"tmux-sessionhookvalues-afterpipepane"},{"id":"tmux.SessionHookValues.AfterQueue","name":"AfterQueue","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterQueue returns materialized \"after-queue\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3907,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterQueue","product":"core","slug":"tmux-sessionhookvalues-afterqueue"},{"id":"tmux.SessionHookValues.AfterRefreshClient","name":"AfterRefreshClient","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRefreshClient returns materialized \"after-refresh-client\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3912,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterRefreshClient","product":"core","slug":"tmux-sessionhookvalues-afterrefreshclient"},{"id":"tmux.SessionHookValues.AfterRenameSession","name":"AfterRenameSession","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRenameSession returns materialized \"after-rename-session\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3919,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterRenameSession","product":"core","slug":"tmux-sessionhookvalues-afterrenamesession"},{"id":"tmux.SessionHookValues.AfterRenameWindow","name":"AfterRenameWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRenameWindow returns materialized \"after-rename-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3926,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterRenameWindow","product":"core","slug":"tmux-sessionhookvalues-afterrenamewindow"},{"id":"tmux.SessionHookValues.AfterResizePane","name":"AfterResizePane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterResizePane returns materialized \"after-resize-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3933,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterResizePane","product":"core","slug":"tmux-sessionhookvalues-afterresizepane"},{"id":"tmux.SessionHookValues.AfterResizeWindow","name":"AfterResizeWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterResizeWindow returns materialized \"after-resize-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3940,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterResizeWindow","product":"core","slug":"tmux-sessionhookvalues-afterresizewindow"},{"id":"tmux.SessionHookValues.AfterSaveBuffer","name":"AfterSaveBuffer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSaveBuffer returns materialized \"after-save-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3947,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSaveBuffer","product":"core","slug":"tmux-sessionhookvalues-aftersavebuffer"},{"id":"tmux.SessionHookValues.AfterSelectLayout","name":"AfterSelectLayout","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectLayout returns materialized \"after-select-layout\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3954,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSelectLayout","product":"core","slug":"tmux-sessionhookvalues-afterselectlayout"},{"id":"tmux.SessionHookValues.AfterSelectPane","name":"AfterSelectPane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectPane returns materialized \"after-select-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3961,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSelectPane","product":"core","slug":"tmux-sessionhookvalues-afterselectpane"},{"id":"tmux.SessionHookValues.AfterSelectWindow","name":"AfterSelectWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectWindow returns materialized \"after-select-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3968,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSelectWindow","product":"core","slug":"tmux-sessionhookvalues-afterselectwindow"},{"id":"tmux.SessionHookValues.AfterSendKeys","name":"AfterSendKeys","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSendKeys returns materialized \"after-send-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3975,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSendKeys","product":"core","slug":"tmux-sessionhookvalues-aftersendkeys"},{"id":"tmux.SessionHookValues.AfterSetBuffer","name":"AfterSetBuffer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetBuffer returns materialized \"after-set-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3980,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSetBuffer","product":"core","slug":"tmux-sessionhookvalues-aftersetbuffer"},{"id":"tmux.SessionHookValues.AfterSetEnvironment","name":"AfterSetEnvironment","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetEnvironment returns materialized \"after-set-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3985,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSetEnvironment","product":"core","slug":"tmux-sessionhookvalues-aftersetenvironment"},{"id":"tmux.SessionHookValues.AfterSetHook","name":"AfterSetHook","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetHook returns materialized \"after-set-hook\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3992,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSetHook","product":"core","slug":"tmux-sessionhookvalues-aftersethook"},{"id":"tmux.SessionHookValues.AfterSetOption","name":"AfterSetOption","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetOption returns materialized \"after-set-option\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3997,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSetOption","product":"core","slug":"tmux-sessionhookvalues-aftersetoption"},{"id":"tmux.SessionHookValues.AfterShowEnvironment","name":"AfterShowEnvironment","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowEnvironment returns materialized \"after-show-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4002,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterShowEnvironment","product":"core","slug":"tmux-sessionhookvalues-aftershowenvironment"},{"id":"tmux.SessionHookValues.AfterShowMessages","name":"AfterShowMessages","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowMessages returns materialized \"after-show-messages\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4009,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterShowMessages","product":"core","slug":"tmux-sessionhookvalues-aftershowmessages"},{"id":"tmux.SessionHookValues.AfterShowOptions","name":"AfterShowOptions","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowOptions returns materialized \"after-show-options\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4016,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterShowOptions","product":"core","slug":"tmux-sessionhookvalues-aftershowoptions"},{"id":"tmux.SessionHookValues.AfterSplitWindow","name":"AfterSplitWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSplitWindow returns materialized \"after-split-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4023,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterSplitWindow","product":"core","slug":"tmux-sessionhookvalues-aftersplitwindow"},{"id":"tmux.SessionHookValues.AfterUnbindKey","name":"AfterUnbindKey","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterUnbindKey returns materialized \"after-unbind-key\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4030,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AfterUnbindKey","product":"core","slug":"tmux-sessionhookvalues-afterunbindkey"},{"id":"tmux.SessionHookValues.AlertActivity","name":"AlertActivity","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertActivity returns materialized \"alert-activity\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4035,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AlertActivity","product":"core","slug":"tmux-sessionhookvalues-alertactivity"},{"id":"tmux.SessionHookValues.AlertBell","name":"AlertBell","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertBell returns materialized \"alert-bell\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4040,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AlertBell","product":"core","slug":"tmux-sessionhookvalues-alertbell"},{"id":"tmux.SessionHookValues.AlertSilence","name":"AlertSilence","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertSilence returns materialized \"alert-silence\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4045,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.AlertSilence","product":"core","slug":"tmux-sessionhookvalues-alertsilence"},{"id":"tmux.SessionHookValues.ClientActive","name":"ClientActive","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientActive returns materialized \"client-active\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4050,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientActive","product":"core","slug":"tmux-sessionhookvalues-clientactive"},{"id":"tmux.SessionHookValues.ClientAttached","name":"ClientAttached","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientAttached returns materialized \"client-attached\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4055,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientAttached","product":"core","slug":"tmux-sessionhookvalues-clientattached"},{"id":"tmux.SessionHookValues.ClientDarkTheme","name":"ClientDarkTheme","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientDarkTheme returns materialized \"client-dark-theme\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.6. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4060,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientDarkTheme","product":"core","slug":"tmux-sessionhookvalues-clientdarktheme"},{"id":"tmux.SessionHookValues.ClientDetached","name":"ClientDetached","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientDetached returns materialized \"client-detached\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4067,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientDetached","product":"core","slug":"tmux-sessionhookvalues-clientdetached"},{"id":"tmux.SessionHookValues.ClientFocusIn","name":"ClientFocusIn","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientFocusIn returns materialized \"client-focus-in\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4072,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientFocusIn","product":"core","slug":"tmux-sessionhookvalues-clientfocusin"},{"id":"tmux.SessionHookValues.ClientFocusOut","name":"ClientFocusOut","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientFocusOut returns materialized \"client-focus-out\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4077,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientFocusOut","product":"core","slug":"tmux-sessionhookvalues-clientfocusout"},{"id":"tmux.SessionHookValues.ClientLightTheme","name":"ClientLightTheme","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientLightTheme returns materialized \"client-light-theme\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.6. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4082,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientLightTheme","product":"core","slug":"tmux-sessionhookvalues-clientlighttheme"},{"id":"tmux.SessionHookValues.ClientResized","name":"ClientResized","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientResized returns materialized \"client-resized\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4089,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientResized","product":"core","slug":"tmux-sessionhookvalues-clientresized"},{"id":"tmux.SessionHookValues.ClientSessionChanged","name":"ClientSessionChanged","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientSessionChanged returns materialized \"client-session-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4094,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.ClientSessionChanged","product":"core","slug":"tmux-sessionhookvalues-clientsessionchanged"},{"id":"tmux.SessionHookValues.CommandError","name":"CommandError","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"CommandError returns materialized \"command-error\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.5. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4101,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.CommandError","product":"core","slug":"tmux-sessionhookvalues-commanderror"},{"id":"tmux.SessionHookValues.SessionClosed","name":"SessionClosed","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionClosed returns materialized \"session-closed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.SessionClosed","product":"core","slug":"tmux-sessionhookvalues-sessionclosed"},{"id":"tmux.SessionHookValues.SessionCreated","name":"SessionCreated","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionCreated returns materialized \"session-created\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.SessionCreated","product":"core","slug":"tmux-sessionhookvalues-sessioncreated"},{"id":"tmux.SessionHookValues.SessionRenamed","name":"SessionRenamed","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionRenamed returns materialized \"session-renamed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4116,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.SessionRenamed","product":"core","slug":"tmux-sessionhookvalues-sessionrenamed"},{"id":"tmux.SessionHookValues.SessionWindowChanged","name":"SessionWindowChanged","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionWindowChanged returns materialized \"session-window-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4121,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.SessionWindowChanged","product":"core","slug":"tmux-sessionhookvalues-sessionwindowchanged"},{"id":"tmux.SessionHookValues.WindowLinked","name":"WindowLinked","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowLinked returns materialized \"window-linked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4128,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.WindowLinked","product":"core","slug":"tmux-sessionhookvalues-windowlinked"},{"id":"tmux.SessionHookValues.WindowUnlinked","name":"WindowUnlinked","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowUnlinked returns materialized \"window-unlinked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4133,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionHookValues.WindowUnlinked","product":"core","slug":"tmux-sessionhookvalues-windowunlinked"},{"id":"tmux.WindowHookValues","name":"WindowHookValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowHookValues is an immutable materialized view of known window hook values; its zero value is empty and it does not refresh. Obtain it with [Window.Hooks] or [GlobalWindowScope.Hooks]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Window.RawHook] or [GlobalWindowScope.RawHook] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":4261,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues","product":"core","slug":"tmux-windowhookvalues"},{"id":"tmux.WindowHookValues.PaneDied","name":"PaneDied","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneDied returns materialized \"pane-died\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4280,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.PaneDied","product":"core","slug":"tmux-windowhookvalues-panedied"},{"id":"tmux.WindowHookValues.PaneExited","name":"PaneExited","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneExited returns materialized \"pane-exited\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4285,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.PaneExited","product":"core","slug":"tmux-windowhookvalues-paneexited"},{"id":"tmux.WindowHookValues.PaneFocusIn","name":"PaneFocusIn","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneFocusIn returns materialized \"pane-focus-in\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4290,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.PaneFocusIn","product":"core","slug":"tmux-windowhookvalues-panefocusin"},{"id":"tmux.WindowHookValues.PaneFocusOut","name":"PaneFocusOut","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneFocusOut returns materialized \"pane-focus-out\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4295,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.PaneFocusOut","product":"core","slug":"tmux-windowhookvalues-panefocusout"},{"id":"tmux.WindowHookValues.PaneModeChanged","name":"PaneModeChanged","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneModeChanged returns materialized \"pane-mode-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4300,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.PaneModeChanged","product":"core","slug":"tmux-windowhookvalues-panemodechanged"},{"id":"tmux.WindowHookValues.PaneSetClipboard","name":"PaneSetClipboard","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneSetClipboard returns materialized \"pane-set-clipboard\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4307,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.PaneSetClipboard","product":"core","slug":"tmux-windowhookvalues-panesetclipboard"},{"id":"tmux.WindowHookValues.PaneTitleChanged","name":"PaneTitleChanged","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneTitleChanged returns materialized \"pane-title-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4314,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.PaneTitleChanged","product":"core","slug":"tmux-windowhookvalues-panetitlechanged"},{"id":"tmux.WindowHookValues.WindowLayoutChanged","name":"WindowLayoutChanged","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowLayoutChanged returns materialized \"window-layout-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4321,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.WindowLayoutChanged","product":"core","slug":"tmux-windowhookvalues-windowlayoutchanged"},{"id":"tmux.WindowHookValues.WindowLinked","name":"WindowLinked","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowLinked returns materialized \"window-linked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4328,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.WindowLinked","product":"core","slug":"tmux-windowhookvalues-windowlinked"},{"id":"tmux.WindowHookValues.WindowPaneChanged","name":"WindowPaneChanged","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowPaneChanged returns materialized \"window-pane-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4333,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.WindowPaneChanged","product":"core","slug":"tmux-windowhookvalues-windowpanechanged"},{"id":"tmux.WindowHookValues.WindowRenamed","name":"WindowRenamed","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowRenamed returns materialized \"window-renamed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4340,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.WindowRenamed","product":"core","slug":"tmux-windowhookvalues-windowrenamed"},{"id":"tmux.WindowHookValues.WindowResized","name":"WindowResized","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowResized returns materialized \"window-resized\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4345,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.WindowResized","product":"core","slug":"tmux-windowhookvalues-windowresized"},{"id":"tmux.WindowHookValues.WindowUnlinked","name":"WindowUnlinked","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowUnlinked returns materialized \"window-unlinked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4350,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowHookValues.WindowUnlinked","product":"core","slug":"tmux-windowhookvalues-windowunlinked"},{"id":"tmux.PaneHookValues","name":"PaneHookValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneHookValues is an immutable materialized view of known pane hook values; its zero value is empty and it does not refresh. Obtain it with [Pane.Hooks]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Pane.RawHook] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":4390,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneHookValues","product":"core","slug":"tmux-panehookvalues"},{"id":"tmux.PaneHookValues.PaneDied","name":"PaneDied","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneDied returns materialized \"pane-died\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4403,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneHookValues.PaneDied","product":"core","slug":"tmux-panehookvalues-panedied"},{"id":"tmux.PaneHookValues.PaneExited","name":"PaneExited","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneExited returns materialized \"pane-exited\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4408,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneHookValues.PaneExited","product":"core","slug":"tmux-panehookvalues-paneexited"},{"id":"tmux.PaneHookValues.PaneFocusIn","name":"PaneFocusIn","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneFocusIn returns materialized \"pane-focus-in\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4413,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneHookValues.PaneFocusIn","product":"core","slug":"tmux-panehookvalues-panefocusin"},{"id":"tmux.PaneHookValues.PaneFocusOut","name":"PaneFocusOut","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneFocusOut returns materialized \"pane-focus-out\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4418,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneHookValues.PaneFocusOut","product":"core","slug":"tmux-panehookvalues-panefocusout"},{"id":"tmux.PaneHookValues.PaneModeChanged","name":"PaneModeChanged","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneModeChanged returns materialized \"pane-mode-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4423,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneHookValues.PaneModeChanged","product":"core","slug":"tmux-panehookvalues-panemodechanged"},{"id":"tmux.PaneHookValues.PaneSetClipboard","name":"PaneSetClipboard","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneSetClipboard returns materialized \"pane-set-clipboard\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4428,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneHookValues.PaneSetClipboard","product":"core","slug":"tmux-panehookvalues-panesetclipboard"},{"id":"tmux.PaneHookValues.PaneTitleChanged","name":"PaneTitleChanged","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneTitleChanged returns materialized \"pane-title-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4435,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneHookValues.PaneTitleChanged","product":"core","slug":"tmux-panehookvalues-panetitlechanged"},{"id":"tmux.Session.SetActivityAction","name":"SetActivityAction","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ActivityAction"}],"returns":"error"}],"doc":{"summary":"SetActivityAction stores the \"activity-action\" session option as ActivityAction (tmux 3.2a or later). Read it with [SessionOptionValues.ActivityAction] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4464,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetActivityAction","product":"core","slug":"tmux-session-setactivityaction"},{"id":"tmux.GlobalSessionScope.SetActivityAction","name":"SetActivityAction","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ActivityAction"}],"returns":"error"}],"doc":{"summary":"SetActivityAction stores the \"activity-action\" session option as ActivityAction (tmux 3.2a or later). Read it with [SessionOptionValues.ActivityAction] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4474,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetActivityAction","product":"core","slug":"tmux-globalsessionscope-setactivityaction"},{"id":"tmux.Window.SetAggressiveResize","name":"SetAggressiveResize","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAggressiveResize stores the \"aggressive-resize\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AggressiveResize] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4482,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetAggressiveResize","product":"core","slug":"tmux-window-setaggressiveresize"},{"id":"tmux.GlobalWindowScope.SetAggressiveResize","name":"SetAggressiveResize","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAggressiveResize stores the \"aggressive-resize\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AggressiveResize] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4492,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetAggressiveResize","product":"core","slug":"tmux-globalwindowscope-setaggressiveresize"},{"id":"tmux.Window.SetAllowPassthrough","name":"SetAllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"AllowPassthrough"}],"returns":"error"}],"doc":{"summary":"SetAllowPassthrough stores the \"allow-passthrough\" window option as AllowPassthrough (tmux 3.3 or later). Read it with [WindowOptionValues.AllowPassthrough] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4500,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetAllowPassthrough","product":"core","slug":"tmux-window-setallowpassthrough"},{"id":"tmux.GlobalWindowScope.SetAllowPassthrough","name":"SetAllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"AllowPassthrough"}],"returns":"error"}],"doc":{"summary":"SetAllowPassthrough stores the \"allow-passthrough\" window option as AllowPassthrough (tmux 3.3 or later). Read it with [WindowOptionValues.AllowPassthrough] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4510,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetAllowPassthrough","product":"core","slug":"tmux-globalwindowscope-setallowpassthrough"},{"id":"tmux.Pane.SetAllowPassthrough","name":"SetAllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"AllowPassthrough"}],"returns":"error"}],"doc":{"summary":"SetAllowPassthrough stores the \"allow-passthrough\" pane option as AllowPassthrough (tmux 3.3 or later). Read it with [PaneOptionValues.AllowPassthrough] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4518,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetAllowPassthrough","product":"core","slug":"tmux-pane-setallowpassthrough"},{"id":"tmux.Window.SetAllowRename","name":"SetAllowRename","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowRename stores the \"allow-rename\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AllowRename] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4528,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetAllowRename","product":"core","slug":"tmux-window-setallowrename"},{"id":"tmux.GlobalWindowScope.SetAllowRename","name":"SetAllowRename","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowRename stores the \"allow-rename\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AllowRename] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4538,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetAllowRename","product":"core","slug":"tmux-globalwindowscope-setallowrename"},{"id":"tmux.Pane.SetAllowRename","name":"SetAllowRename","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowRename stores the \"allow-rename\" pane option as bool (tmux 3.2a or later). Read it with [PaneOptionValues.AllowRename] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4546,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetAllowRename","product":"core","slug":"tmux-pane-setallowrename"},{"id":"tmux.Window.SetAllowSetTitle","name":"SetAllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowSetTitle stores the \"allow-set-title\" window option as bool (tmux 3.5 or later). Read it with [WindowOptionValues.AllowSetTitle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4556,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetAllowSetTitle","product":"core","slug":"tmux-window-setallowsettitle"},{"id":"tmux.GlobalWindowScope.SetAllowSetTitle","name":"SetAllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowSetTitle stores the \"allow-set-title\" window option as bool (tmux 3.5 or later). Read it with [WindowOptionValues.AllowSetTitle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4566,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetAllowSetTitle","product":"core","slug":"tmux-globalwindowscope-setallowsettitle"},{"id":"tmux.Pane.SetAllowSetTitle","name":"SetAllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowSetTitle stores the \"allow-set-title\" pane option as bool (tmux 3.5 or later). Read it with [PaneOptionValues.AllowSetTitle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4574,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetAllowSetTitle","product":"core","slug":"tmux-pane-setallowsettitle"},{"id":"tmux.Window.SetAlternateScreen","name":"SetAlternateScreen","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAlternateScreen stores the \"alternate-screen\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AlternateScreen] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4584,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetAlternateScreen","product":"core","slug":"tmux-window-setalternatescreen"},{"id":"tmux.GlobalWindowScope.SetAlternateScreen","name":"SetAlternateScreen","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAlternateScreen stores the \"alternate-screen\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AlternateScreen] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4594,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetAlternateScreen","product":"core","slug":"tmux-globalwindowscope-setalternatescreen"},{"id":"tmux.Pane.SetAlternateScreen","name":"SetAlternateScreen","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAlternateScreen stores the \"alternate-screen\" pane option as bool (tmux 3.2a or later). Read it with [PaneOptionValues.AlternateScreen] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4602,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetAlternateScreen","product":"core","slug":"tmux-pane-setalternatescreen"},{"id":"tmux.Session.SetAssumePasteTime","name":"SetAssumePasteTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetAssumePasteTime stores the \"assume-paste-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.AssumePasteTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4612,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetAssumePasteTime","product":"core","slug":"tmux-session-setassumepastetime"},{"id":"tmux.GlobalSessionScope.SetAssumePasteTime","name":"SetAssumePasteTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetAssumePasteTime stores the \"assume-paste-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.AssumePasteTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4626,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetAssumePasteTime","product":"core","slug":"tmux-globalsessionscope-setassumepastetime"},{"id":"tmux.Window.SetAutomaticRename","name":"SetAutomaticRename","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAutomaticRename stores the \"automatic-rename\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AutomaticRename] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4638,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetAutomaticRename","product":"core","slug":"tmux-window-setautomaticrename"},{"id":"tmux.GlobalWindowScope.SetAutomaticRename","name":"SetAutomaticRename","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAutomaticRename stores the \"automatic-rename\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AutomaticRename] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4648,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetAutomaticRename","product":"core","slug":"tmux-globalwindowscope-setautomaticrename"},{"id":"tmux.Window.SetAutomaticRenameFormat","name":"SetAutomaticRenameFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetAutomaticRenameFormat stores the \"automatic-rename-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.AutomaticRenameFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4656,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetAutomaticRenameFormat","product":"core","slug":"tmux-window-setautomaticrenameformat"},{"id":"tmux.GlobalWindowScope.SetAutomaticRenameFormat","name":"SetAutomaticRenameFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetAutomaticRenameFormat stores the \"automatic-rename-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.AutomaticRenameFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4666,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetAutomaticRenameFormat","product":"core","slug":"tmux-globalwindowscope-setautomaticrenameformat"},{"id":"tmux.Server.SetBackspace","name":"SetBackspace","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetBackspace stores the \"backspace\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.Backspace] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4674,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetBackspace","product":"core","slug":"tmux-server-setbackspace"},{"id":"tmux.Session.SetBaseIndex","name":"SetBaseIndex","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetBaseIndex stores the \"base-index\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.BaseIndex] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4682,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetBaseIndex","product":"core","slug":"tmux-session-setbaseindex"},{"id":"tmux.GlobalSessionScope.SetBaseIndex","name":"SetBaseIndex","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetBaseIndex stores the \"base-index\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.BaseIndex] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4692,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetBaseIndex","product":"core","slug":"tmux-globalsessionscope-setbaseindex"},{"id":"tmux.Session.SetBellAction","name":"SetBellAction","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"BellAction"}],"returns":"error"}],"doc":{"summary":"SetBellAction stores the \"bell-action\" session option as BellAction (tmux 3.2a or later). Read it with [SessionOptionValues.BellAction] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4700,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetBellAction","product":"core","slug":"tmux-session-setbellaction"},{"id":"tmux.GlobalSessionScope.SetBellAction","name":"SetBellAction","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"BellAction"}],"returns":"error"}],"doc":{"summary":"SetBellAction stores the \"bell-action\" session option as BellAction (tmux 3.2a or later). Read it with [SessionOptionValues.BellAction] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4710,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetBellAction","product":"core","slug":"tmux-globalsessionscope-setbellaction"},{"id":"tmux.Server.SetBufferLimit","name":"SetBufferLimit","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetBufferLimit stores the \"buffer-limit\" server option as int64 (tmux 3.2a or later). Read it with [ServerOptionValues.BufferLimit] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4718,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetBufferLimit","product":"core","slug":"tmux-server-setbufferlimit"},{"id":"tmux.Window.SetClockModeColour","name":"SetClockModeColour","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetClockModeColour stores the \"clock-mode-colour\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.ClockModeColour] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4726,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetClockModeColour","product":"core","slug":"tmux-window-setclockmodecolour"},{"id":"tmux.GlobalWindowScope.SetClockModeColour","name":"SetClockModeColour","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetClockModeColour stores the \"clock-mode-colour\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.ClockModeColour] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4736,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetClockModeColour","product":"core","slug":"tmux-globalwindowscope-setclockmodecolour"},{"id":"tmux.Window.SetClockModeStyle","name":"SetClockModeStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ClockModeStyle"}],"returns":"error"}],"doc":{"summary":"SetClockModeStyle stores the \"clock-mode-style\" window option as ClockModeStyle (tmux 3.2a or later). Read it with [WindowOptionValues.ClockModeStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4744,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetClockModeStyle","product":"core","slug":"tmux-window-setclockmodestyle"},{"id":"tmux.GlobalWindowScope.SetClockModeStyle","name":"SetClockModeStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ClockModeStyle"}],"returns":"error"}],"doc":{"summary":"SetClockModeStyle stores the \"clock-mode-style\" window option as ClockModeStyle (tmux 3.2a or later). Read it with [WindowOptionValues.ClockModeStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4754,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetClockModeStyle","product":"core","slug":"tmux-globalwindowscope-setclockmodestyle"},{"id":"tmux.Server.SetCopyCommand","name":"SetCopyCommand","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyCommand stores the \"copy-command\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.CopyCommand] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4762,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetCopyCommand","product":"core","slug":"tmux-server-setcopycommand"},{"id":"tmux.Window.SetCopyModeCurrentLineNumberStyle","name":"SetCopyModeCurrentLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeCurrentLineNumberStyle stores the \"copy-mode-current-line-number-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeCurrentLineNumberStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4770,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModeCurrentLineNumberStyle","product":"core","slug":"tmux-window-setcopymodecurrentlinenumberstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeCurrentLineNumberStyle","name":"SetCopyModeCurrentLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeCurrentLineNumberStyle stores the \"copy-mode-current-line-number-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeCurrentLineNumberStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4780,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModeCurrentLineNumberStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodecurrentlinenumberstyle"},{"id":"tmux.Window.SetCopyModeCurrentMatchStyle","name":"SetCopyModeCurrentMatchStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeCurrentMatchStyle stores the \"copy-mode-current-match-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeCurrentMatchStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4788,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModeCurrentMatchStyle","product":"core","slug":"tmux-window-setcopymodecurrentmatchstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeCurrentMatchStyle","name":"SetCopyModeCurrentMatchStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeCurrentMatchStyle stores the \"copy-mode-current-match-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeCurrentMatchStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4798,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModeCurrentMatchStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodecurrentmatchstyle"},{"id":"tmux.Window.SetCopyModeLineNumberStyle","name":"SetCopyModeLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeLineNumberStyle stores the \"copy-mode-line-number-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeLineNumberStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4806,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModeLineNumberStyle","product":"core","slug":"tmux-window-setcopymodelinenumberstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeLineNumberStyle","name":"SetCopyModeLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeLineNumberStyle stores the \"copy-mode-line-number-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeLineNumberStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4816,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModeLineNumberStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodelinenumberstyle"},{"id":"tmux.Window.SetCopyModeLineNumbers","name":"SetCopyModeLineNumbers","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CopyModeLineNumbers"}],"returns":"error"}],"doc":{"summary":"SetCopyModeLineNumbers stores the \"copy-mode-line-numbers\" window option as CopyModeLineNumbers (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeLineNumbers] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4824,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModeLineNumbers","product":"core","slug":"tmux-window-setcopymodelinenumbers"},{"id":"tmux.GlobalWindowScope.SetCopyModeLineNumbers","name":"SetCopyModeLineNumbers","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CopyModeLineNumbers"}],"returns":"error"}],"doc":{"summary":"SetCopyModeLineNumbers stores the \"copy-mode-line-numbers\" window option as CopyModeLineNumbers (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeLineNumbers] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4834,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModeLineNumbers","product":"core","slug":"tmux-globalwindowscope-setcopymodelinenumbers"},{"id":"tmux.Window.SetCopyModeMarkStyle","name":"SetCopyModeMarkStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeMarkStyle stores the \"copy-mode-mark-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeMarkStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4842,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModeMarkStyle","product":"core","slug":"tmux-window-setcopymodemarkstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeMarkStyle","name":"SetCopyModeMarkStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeMarkStyle stores the \"copy-mode-mark-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeMarkStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4852,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModeMarkStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodemarkstyle"},{"id":"tmux.Window.SetCopyModeMatchStyle","name":"SetCopyModeMatchStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeMatchStyle stores the \"copy-mode-match-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeMatchStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4860,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModeMatchStyle","product":"core","slug":"tmux-window-setcopymodematchstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeMatchStyle","name":"SetCopyModeMatchStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeMatchStyle stores the \"copy-mode-match-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeMatchStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4870,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModeMatchStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodematchstyle"},{"id":"tmux.Window.SetCopyModePositionFormat","name":"SetCopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionFormat stores the \"copy-mode-position-format\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModePositionFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4878,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModePositionFormat","product":"core","slug":"tmux-window-setcopymodepositionformat"},{"id":"tmux.GlobalWindowScope.SetCopyModePositionFormat","name":"SetCopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionFormat stores the \"copy-mode-position-format\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModePositionFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4888,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModePositionFormat","product":"core","slug":"tmux-globalwindowscope-setcopymodepositionformat"},{"id":"tmux.Pane.SetCopyModePositionFormat","name":"SetCopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionFormat stores the \"copy-mode-position-format\" pane option as string (tmux 3.6 or later). Read it with [PaneOptionValues.CopyModePositionFormat] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4896,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetCopyModePositionFormat","product":"core","slug":"tmux-pane-setcopymodepositionformat"},{"id":"tmux.Window.SetCopyModePositionStyle","name":"SetCopyModePositionStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionStyle stores the \"copy-mode-position-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModePositionStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4906,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModePositionStyle","product":"core","slug":"tmux-window-setcopymodepositionstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModePositionStyle","name":"SetCopyModePositionStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionStyle stores the \"copy-mode-position-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModePositionStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4916,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModePositionStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodepositionstyle"},{"id":"tmux.Window.SetCopyModeSelectionStyle","name":"SetCopyModeSelectionStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeSelectionStyle stores the \"copy-mode-selection-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModeSelectionStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4924,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCopyModeSelectionStyle","product":"core","slug":"tmux-window-setcopymodeselectionstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeSelectionStyle","name":"SetCopyModeSelectionStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeSelectionStyle stores the \"copy-mode-selection-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModeSelectionStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4934,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCopyModeSelectionStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodeselectionstyle"},{"id":"tmux.Window.SetCursorColour","name":"SetCursorColour","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCursorColour stores the \"cursor-colour\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.CursorColour] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4942,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCursorColour","product":"core","slug":"tmux-window-setcursorcolour"},{"id":"tmux.GlobalWindowScope.SetCursorColour","name":"SetCursorColour","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCursorColour stores the \"cursor-colour\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.CursorColour] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4952,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCursorColour","product":"core","slug":"tmux-globalwindowscope-setcursorcolour"},{"id":"tmux.Pane.SetCursorColour","name":"SetCursorColour","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCursorColour stores the \"cursor-colour\" pane option as string (tmux 3.3 or later). Read it with [PaneOptionValues.CursorColour] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4960,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetCursorColour","product":"core","slug":"tmux-pane-setcursorcolour"},{"id":"tmux.Window.SetCursorStyle","name":"SetCursorStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CursorStyle"}],"returns":"error"}],"doc":{"summary":"SetCursorStyle stores the \"cursor-style\" window option as CursorStyle (tmux 3.3 or later). Read it with [WindowOptionValues.CursorStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4970,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetCursorStyle","product":"core","slug":"tmux-window-setcursorstyle"},{"id":"tmux.GlobalWindowScope.SetCursorStyle","name":"SetCursorStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CursorStyle"}],"returns":"error"}],"doc":{"summary":"SetCursorStyle stores the \"cursor-style\" window option as CursorStyle (tmux 3.3 or later). Read it with [WindowOptionValues.CursorStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4980,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetCursorStyle","product":"core","slug":"tmux-globalwindowscope-setcursorstyle"},{"id":"tmux.Pane.SetCursorStyle","name":"SetCursorStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CursorStyle"}],"returns":"error"}],"doc":{"summary":"SetCursorStyle stores the \"cursor-style\" pane option as CursorStyle (tmux 3.3 or later). Read it with [PaneOptionValues.CursorStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4988,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetCursorStyle","product":"core","slug":"tmux-pane-setcursorstyle"},{"id":"tmux.Server.SetDefaultClientCommand","name":"SetDefaultClientCommand","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultClientCommand stores the \"default-client-command\" server option as string (tmux 3.6 or later). Read it with [ServerOptionValues.DefaultClientCommand] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4998,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetDefaultClientCommand","product":"core","slug":"tmux-server-setdefaultclientcommand"},{"id":"tmux.Session.SetDefaultCommand","name":"SetDefaultCommand","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultCommand stores the \"default-command\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultCommand] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5006,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDefaultCommand","product":"core","slug":"tmux-session-setdefaultcommand"},{"id":"tmux.GlobalSessionScope.SetDefaultCommand","name":"SetDefaultCommand","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultCommand stores the \"default-command\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultCommand] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5016,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDefaultCommand","product":"core","slug":"tmux-globalsessionscope-setdefaultcommand"},{"id":"tmux.Session.SetDefaultShell","name":"SetDefaultShell","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultShell stores the \"default-shell\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultShell] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5024,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDefaultShell","product":"core","slug":"tmux-session-setdefaultshell"},{"id":"tmux.GlobalSessionScope.SetDefaultShell","name":"SetDefaultShell","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultShell stores the \"default-shell\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultShell] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5034,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDefaultShell","product":"core","slug":"tmux-globalsessionscope-setdefaultshell"},{"id":"tmux.Session.SetDefaultSize","name":"SetDefaultSize","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultSize stores the \"default-size\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultSize] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5042,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDefaultSize","product":"core","slug":"tmux-session-setdefaultsize"},{"id":"tmux.GlobalSessionScope.SetDefaultSize","name":"SetDefaultSize","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultSize stores the \"default-size\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultSize] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5052,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDefaultSize","product":"core","slug":"tmux-globalsessionscope-setdefaultsize"},{"id":"tmux.Server.SetDefaultTerminal","name":"SetDefaultTerminal","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultTerminal stores the \"default-terminal\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.DefaultTerminal] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5060,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetDefaultTerminal","product":"core","slug":"tmux-server-setdefaultterminal"},{"id":"tmux.Session.SetDestroyUnattached","name":"SetDestroyUnattached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"DestroyUnattached"}],"returns":"error"}],"doc":{"summary":"SetDestroyUnattached stores the \"destroy-unattached\" session option as DestroyUnattached (tmux 3.2a or later). Read it with [SessionOptionValues.DestroyUnattached] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5068,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDestroyUnattached","product":"core","slug":"tmux-session-setdestroyunattached"},{"id":"tmux.GlobalSessionScope.SetDestroyUnattached","name":"SetDestroyUnattached","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"DestroyUnattached"}],"returns":"error"}],"doc":{"summary":"SetDestroyUnattached stores the \"destroy-unattached\" session option as DestroyUnattached (tmux 3.2a or later). Read it with [SessionOptionValues.DestroyUnattached] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5078,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDestroyUnattached","product":"core","slug":"tmux-globalsessionscope-setdestroyunattached"},{"id":"tmux.Session.SetDetachOnDestroy","name":"SetDetachOnDestroy","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"DetachOnDestroy"}],"returns":"error"}],"doc":{"summary":"SetDetachOnDestroy stores the \"detach-on-destroy\" session option as DetachOnDestroy (tmux 3.2a or later). Read it with [SessionOptionValues.DetachOnDestroy] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5086,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDetachOnDestroy","product":"core","slug":"tmux-session-setdetachondestroy"},{"id":"tmux.GlobalSessionScope.SetDetachOnDestroy","name":"SetDetachOnDestroy","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"DetachOnDestroy"}],"returns":"error"}],"doc":{"summary":"SetDetachOnDestroy stores the \"detach-on-destroy\" session option as DetachOnDestroy (tmux 3.2a or later). Read it with [SessionOptionValues.DetachOnDestroy] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5096,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDetachOnDestroy","product":"core","slug":"tmux-globalsessionscope-setdetachondestroy"},{"id":"tmux.Session.SetDisplayPanesActiveColour","name":"SetDisplayPanesActiveColour","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesActiveColour stores the \"display-panes-active-colour\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesActiveColour] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5104,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDisplayPanesActiveColour","product":"core","slug":"tmux-session-setdisplaypanesactivecolour"},{"id":"tmux.GlobalSessionScope.SetDisplayPanesActiveColour","name":"SetDisplayPanesActiveColour","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesActiveColour stores the \"display-panes-active-colour\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesActiveColour] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5114,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDisplayPanesActiveColour","product":"core","slug":"tmux-globalsessionscope-setdisplaypanesactivecolour"},{"id":"tmux.Session.SetDisplayPanesColour","name":"SetDisplayPanesColour","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesColour stores the \"display-panes-colour\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesColour] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5122,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDisplayPanesColour","product":"core","slug":"tmux-session-setdisplaypanescolour"},{"id":"tmux.GlobalSessionScope.SetDisplayPanesColour","name":"SetDisplayPanesColour","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesColour stores the \"display-panes-colour\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesColour] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5132,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDisplayPanesColour","product":"core","slug":"tmux-globalsessionscope-setdisplaypanescolour"},{"id":"tmux.Session.SetDisplayPanesTime","name":"SetDisplayPanesTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesTime stores the \"display-panes-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5140,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDisplayPanesTime","product":"core","slug":"tmux-session-setdisplaypanestime"},{"id":"tmux.GlobalSessionScope.SetDisplayPanesTime","name":"SetDisplayPanesTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesTime stores the \"display-panes-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5154,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDisplayPanesTime","product":"core","slug":"tmux-globalsessionscope-setdisplaypanestime"},{"id":"tmux.Session.SetDisplayTime","name":"SetDisplayTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetDisplayTime stores the \"display-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5166,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetDisplayTime","product":"core","slug":"tmux-session-setdisplaytime"},{"id":"tmux.GlobalSessionScope.SetDisplayTime","name":"SetDisplayTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetDisplayTime stores the \"display-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5180,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetDisplayTime","product":"core","slug":"tmux-globalsessionscope-setdisplaytime"},{"id":"tmux.Server.SetEditor","name":"SetEditor","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetEditor stores the \"editor\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.Editor] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5192,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetEditor","product":"core","slug":"tmux-server-seteditor"},{"id":"tmux.Server.SetEscapeTime","name":"SetEscapeTime","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetEscapeTime stores the \"escape-time\" server option as time.Duration (tmux 3.2a or later). Read it with [ServerOptionValues.EscapeTime] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5200,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetEscapeTime","product":"core","slug":"tmux-server-setescapetime"},{"id":"tmux.Server.SetExitEmpty","name":"SetExitEmpty","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetExitEmpty stores the \"exit-empty\" server option as bool (tmux 3.2a or later). Read it with [ServerOptionValues.ExitEmpty] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5212,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetExitEmpty","product":"core","slug":"tmux-server-setexitempty"},{"id":"tmux.Server.SetExitUnattached","name":"SetExitUnattached","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetExitUnattached stores the \"exit-unattached\" server option as bool (tmux 3.2a or later). Read it with [ServerOptionValues.ExitUnattached] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5220,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetExitUnattached","product":"core","slug":"tmux-server-setexitunattached"},{"id":"tmux.Server.SetExtendedKeys","name":"SetExtendedKeys","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ExtendedKeys"}],"returns":"error"}],"doc":{"summary":"SetExtendedKeys stores the \"extended-keys\" server option as ExtendedKeys (tmux 3.2a or later). Read it with [ServerOptionValues.ExtendedKeys] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5228,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetExtendedKeys","product":"core","slug":"tmux-server-setextendedkeys"},{"id":"tmux.Server.SetExtendedKeysFormat","name":"SetExtendedKeysFormat","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ExtendedKeysFormat"}],"returns":"error"}],"doc":{"summary":"SetExtendedKeysFormat stores the \"extended-keys-format\" server option as ExtendedKeysFormat (tmux 3.5 or later). Read it with [ServerOptionValues.ExtendedKeysFormat] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5236,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetExtendedKeysFormat","product":"core","slug":"tmux-server-setextendedkeysformat"},{"id":"tmux.Window.SetFillCharacter","name":"SetFillCharacter","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetFillCharacter stores the \"fill-character\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.FillCharacter] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5244,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetFillCharacter","product":"core","slug":"tmux-window-setfillcharacter"},{"id":"tmux.GlobalWindowScope.SetFillCharacter","name":"SetFillCharacter","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetFillCharacter stores the \"fill-character\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.FillCharacter] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5254,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetFillCharacter","product":"core","slug":"tmux-globalwindowscope-setfillcharacter"},{"id":"tmux.Server.SetFocusEvents","name":"SetFocusEvents","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetFocusEvents stores the \"focus-events\" server option as bool (tmux 3.2a or later). Read it with [ServerOptionValues.FocusEvents] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5262,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetFocusEvents","product":"core","slug":"tmux-server-setfocusevents"},{"id":"tmux.Session.SetFocusFollowsMouse","name":"SetFocusFollowsMouse","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetFocusFollowsMouse stores the \"focus-follows-mouse\" session option as bool (tmux 3.7 or later). Read it with [SessionOptionValues.FocusFollowsMouse] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5270,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetFocusFollowsMouse","product":"core","slug":"tmux-session-setfocusfollowsmouse"},{"id":"tmux.GlobalSessionScope.SetFocusFollowsMouse","name":"SetFocusFollowsMouse","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetFocusFollowsMouse stores the \"focus-follows-mouse\" session option as bool (tmux 3.7 or later). Read it with [SessionOptionValues.FocusFollowsMouse] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5280,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetFocusFollowsMouse","product":"core","slug":"tmux-globalsessionscope-setfocusfollowsmouse"},{"id":"tmux.Server.SetGetClipboard","name":"SetGetClipboard","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"GetClipboard"}],"returns":"error"}],"doc":{"summary":"SetGetClipboard stores the \"get-clipboard\" server option as GetClipboard (tmux 3.7 or later). Read it with [ServerOptionValues.GetClipboard] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5288,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetGetClipboard","product":"core","slug":"tmux-server-setgetclipboard"},{"id":"tmux.Server.SetHistoryFile","name":"SetHistoryFile","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHistoryFile stores the \"history-file\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.HistoryFile] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5296,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetHistoryFile","product":"core","slug":"tmux-server-sethistoryfile"},{"id":"tmux.Session.SetHistoryLimit","name":"SetHistoryLimit","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetHistoryLimit stores the \"history-limit\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.HistoryLimit] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5304,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetHistoryLimit","product":"core","slug":"tmux-session-sethistorylimit"},{"id":"tmux.GlobalSessionScope.SetHistoryLimit","name":"SetHistoryLimit","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetHistoryLimit stores the \"history-limit\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.HistoryLimit] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5314,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetHistoryLimit","product":"core","slug":"tmux-globalsessionscope-sethistorylimit"},{"id":"tmux.Session.SetInitialRepeatTime","name":"SetInitialRepeatTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetInitialRepeatTime stores the \"initial-repeat-time\" session option as time.Duration (tmux 3.6 or later). Read it with [SessionOptionValues.InitialRepeatTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5322,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetInitialRepeatTime","product":"core","slug":"tmux-session-setinitialrepeattime"},{"id":"tmux.GlobalSessionScope.SetInitialRepeatTime","name":"SetInitialRepeatTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetInitialRepeatTime stores the \"initial-repeat-time\" session option as time.Duration (tmux 3.6 or later). Read it with [SessionOptionValues.InitialRepeatTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5336,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetInitialRepeatTime","product":"core","slug":"tmux-globalsessionscope-setinitialrepeattime"},{"id":"tmux.Server.SetInputBufferSize","name":"SetInputBufferSize","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetInputBufferSize stores the \"input-buffer-size\" server option as int64 (tmux 3.6 or later). Read it with [ServerOptionValues.InputBufferSize] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5348,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetInputBufferSize","product":"core","slug":"tmux-server-setinputbuffersize"},{"id":"tmux.Session.SetKeyTable","name":"SetKeyTable","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetKeyTable stores the \"key-table\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.KeyTable] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5356,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetKeyTable","product":"core","slug":"tmux-session-setkeytable"},{"id":"tmux.GlobalSessionScope.SetKeyTable","name":"SetKeyTable","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetKeyTable stores the \"key-table\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.KeyTable] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5366,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetKeyTable","product":"core","slug":"tmux-globalsessionscope-setkeytable"},{"id":"tmux.Session.SetLockAfterTime","name":"SetLockAfterTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetLockAfterTime stores the \"lock-after-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.LockAfterTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5374,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetLockAfterTime","product":"core","slug":"tmux-session-setlockaftertime"},{"id":"tmux.GlobalSessionScope.SetLockAfterTime","name":"SetLockAfterTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetLockAfterTime stores the \"lock-after-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.LockAfterTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5388,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetLockAfterTime","product":"core","slug":"tmux-globalsessionscope-setlockaftertime"},{"id":"tmux.Session.SetLockCommand","name":"SetLockCommand","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetLockCommand stores the \"lock-command\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.LockCommand] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5400,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetLockCommand","product":"core","slug":"tmux-session-setlockcommand"},{"id":"tmux.GlobalSessionScope.SetLockCommand","name":"SetLockCommand","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetLockCommand stores the \"lock-command\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.LockCommand] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5410,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetLockCommand","product":"core","slug":"tmux-globalsessionscope-setlockcommand"},{"id":"tmux.Window.SetMainPaneHeight","name":"SetMainPaneHeight","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMainPaneHeight stores the \"main-pane-height\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.MainPaneHeight] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5418,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMainPaneHeight","product":"core","slug":"tmux-window-setmainpaneheight"},{"id":"tmux.GlobalWindowScope.SetMainPaneHeight","name":"SetMainPaneHeight","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMainPaneHeight stores the \"main-pane-height\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.MainPaneHeight] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5428,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMainPaneHeight","product":"core","slug":"tmux-globalwindowscope-setmainpaneheight"},{"id":"tmux.Window.SetMainPaneWidth","name":"SetMainPaneWidth","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMainPaneWidth stores the \"main-pane-width\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.MainPaneWidth] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5436,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMainPaneWidth","product":"core","slug":"tmux-window-setmainpanewidth"},{"id":"tmux.GlobalWindowScope.SetMainPaneWidth","name":"SetMainPaneWidth","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMainPaneWidth stores the \"main-pane-width\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.MainPaneWidth] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5446,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMainPaneWidth","product":"core","slug":"tmux-globalwindowscope-setmainpanewidth"},{"id":"tmux.Window.SetMenuBorderLines","name":"SetMenuBorderLines","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"MenuBorderLines"}],"returns":"error"}],"doc":{"summary":"SetMenuBorderLines stores the \"menu-border-lines\" window option as MenuBorderLines (tmux 3.4 or later). Read it with [WindowOptionValues.MenuBorderLines] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5454,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMenuBorderLines","product":"core","slug":"tmux-window-setmenuborderlines"},{"id":"tmux.GlobalWindowScope.SetMenuBorderLines","name":"SetMenuBorderLines","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"MenuBorderLines"}],"returns":"error"}],"doc":{"summary":"SetMenuBorderLines stores the \"menu-border-lines\" window option as MenuBorderLines (tmux 3.4 or later). Read it with [WindowOptionValues.MenuBorderLines] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5464,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMenuBorderLines","product":"core","slug":"tmux-globalwindowscope-setmenuborderlines"},{"id":"tmux.Window.SetMenuBorderStyle","name":"SetMenuBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuBorderStyle stores the \"menu-border-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuBorderStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5472,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMenuBorderStyle","product":"core","slug":"tmux-window-setmenuborderstyle"},{"id":"tmux.GlobalWindowScope.SetMenuBorderStyle","name":"SetMenuBorderStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuBorderStyle stores the \"menu-border-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuBorderStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5482,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMenuBorderStyle","product":"core","slug":"tmux-globalwindowscope-setmenuborderstyle"},{"id":"tmux.Window.SetMenuSelectedStyle","name":"SetMenuSelectedStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuSelectedStyle stores the \"menu-selected-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuSelectedStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5490,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMenuSelectedStyle","product":"core","slug":"tmux-window-setmenuselectedstyle"},{"id":"tmux.GlobalWindowScope.SetMenuSelectedStyle","name":"SetMenuSelectedStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuSelectedStyle stores the \"menu-selected-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuSelectedStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5500,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMenuSelectedStyle","product":"core","slug":"tmux-globalwindowscope-setmenuselectedstyle"},{"id":"tmux.Window.SetMenuStyle","name":"SetMenuStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuStyle stores the \"menu-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5508,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMenuStyle","product":"core","slug":"tmux-window-setmenustyle"},{"id":"tmux.GlobalWindowScope.SetMenuStyle","name":"SetMenuStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuStyle stores the \"menu-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5518,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMenuStyle","product":"core","slug":"tmux-globalwindowscope-setmenustyle"},{"id":"tmux.Session.SetMessageCommandStyle","name":"SetMessageCommandStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageCommandStyle stores the \"message-command-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.MessageCommandStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5526,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetMessageCommandStyle","product":"core","slug":"tmux-session-setmessagecommandstyle"},{"id":"tmux.GlobalSessionScope.SetMessageCommandStyle","name":"SetMessageCommandStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageCommandStyle stores the \"message-command-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.MessageCommandStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5536,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetMessageCommandStyle","product":"core","slug":"tmux-globalsessionscope-setmessagecommandstyle"},{"id":"tmux.Session.SetMessageFormat","name":"SetMessageFormat","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageFormat stores the \"message-format\" session option as string (tmux 3.7 or later). Read it with [SessionOptionValues.MessageFormat] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5544,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetMessageFormat","product":"core","slug":"tmux-session-setmessageformat"},{"id":"tmux.GlobalSessionScope.SetMessageFormat","name":"SetMessageFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageFormat stores the \"message-format\" session option as string (tmux 3.7 or later). Read it with [SessionOptionValues.MessageFormat] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5554,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetMessageFormat","product":"core","slug":"tmux-globalsessionscope-setmessageformat"},{"id":"tmux.Server.SetMessageLimit","name":"SetMessageLimit","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetMessageLimit stores the \"message-limit\" server option as int64 (tmux 3.2a or later). Read it with [ServerOptionValues.MessageLimit] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5562,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetMessageLimit","product":"core","slug":"tmux-server-setmessagelimit"},{"id":"tmux.Session.SetMessageLine","name":"SetMessageLine","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"MessageLine"}],"returns":"error"}],"doc":{"summary":"SetMessageLine stores the \"message-line\" session option as MessageLine (tmux 3.4 or later). Read it with [SessionOptionValues.MessageLine] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5570,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetMessageLine","product":"core","slug":"tmux-session-setmessageline"},{"id":"tmux.GlobalSessionScope.SetMessageLine","name":"SetMessageLine","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"MessageLine"}],"returns":"error"}],"doc":{"summary":"SetMessageLine stores the \"message-line\" session option as MessageLine (tmux 3.4 or later). Read it with [SessionOptionValues.MessageLine] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5580,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetMessageLine","product":"core","slug":"tmux-globalsessionscope-setmessageline"},{"id":"tmux.Session.SetMessageStyle","name":"SetMessageStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageStyle stores the \"message-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.MessageStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5588,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetMessageStyle","product":"core","slug":"tmux-session-setmessagestyle"},{"id":"tmux.GlobalSessionScope.SetMessageStyle","name":"SetMessageStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageStyle stores the \"message-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.MessageStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5598,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetMessageStyle","product":"core","slug":"tmux-globalsessionscope-setmessagestyle"},{"id":"tmux.Window.SetModeKeys","name":"SetModeKeys","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ModeKeys"}],"returns":"error"}],"doc":{"summary":"SetModeKeys stores the \"mode-keys\" window option as ModeKeys (tmux 3.2a or later). Read it with [WindowOptionValues.ModeKeys] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5606,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetModeKeys","product":"core","slug":"tmux-window-setmodekeys"},{"id":"tmux.GlobalWindowScope.SetModeKeys","name":"SetModeKeys","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ModeKeys"}],"returns":"error"}],"doc":{"summary":"SetModeKeys stores the \"mode-keys\" window option as ModeKeys (tmux 3.2a or later). Read it with [WindowOptionValues.ModeKeys] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5616,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetModeKeys","product":"core","slug":"tmux-globalwindowscope-setmodekeys"},{"id":"tmux.Window.SetModeStyle","name":"SetModeStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetModeStyle stores the \"mode-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.ModeStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5624,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetModeStyle","product":"core","slug":"tmux-window-setmodestyle"},{"id":"tmux.GlobalWindowScope.SetModeStyle","name":"SetModeStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetModeStyle stores the \"mode-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.ModeStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5634,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetModeStyle","product":"core","slug":"tmux-globalwindowscope-setmodestyle"},{"id":"tmux.Window.SetMonitorActivity","name":"SetMonitorActivity","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMonitorActivity stores the \"monitor-activity\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorActivity] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5642,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMonitorActivity","product":"core","slug":"tmux-window-setmonitoractivity"},{"id":"tmux.GlobalWindowScope.SetMonitorActivity","name":"SetMonitorActivity","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMonitorActivity stores the \"monitor-activity\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorActivity] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5652,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMonitorActivity","product":"core","slug":"tmux-globalwindowscope-setmonitoractivity"},{"id":"tmux.Window.SetMonitorBell","name":"SetMonitorBell","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMonitorBell stores the \"monitor-bell\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorBell] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5660,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMonitorBell","product":"core","slug":"tmux-window-setmonitorbell"},{"id":"tmux.GlobalWindowScope.SetMonitorBell","name":"SetMonitorBell","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMonitorBell stores the \"monitor-bell\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorBell] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5670,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMonitorBell","product":"core","slug":"tmux-globalwindowscope-setmonitorbell"},{"id":"tmux.Window.SetMonitorSilence","name":"SetMonitorSilence","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetMonitorSilence stores the \"monitor-silence\" window option as int64 (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorSilence] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5678,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetMonitorSilence","product":"core","slug":"tmux-window-setmonitorsilence"},{"id":"tmux.GlobalWindowScope.SetMonitorSilence","name":"SetMonitorSilence","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetMonitorSilence stores the \"monitor-silence\" window option as int64 (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorSilence] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5688,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetMonitorSilence","product":"core","slug":"tmux-globalwindowscope-setmonitorsilence"},{"id":"tmux.Session.SetMouse","name":"SetMouse","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMouse stores the \"mouse\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.Mouse] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5696,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetMouse","product":"core","slug":"tmux-session-setmouse"},{"id":"tmux.GlobalSessionScope.SetMouse","name":"SetMouse","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMouse stores the \"mouse\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.Mouse] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5706,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetMouse","product":"core","slug":"tmux-globalsessionscope-setmouse"},{"id":"tmux.Window.SetOtherPaneHeight","name":"SetOtherPaneHeight","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetOtherPaneHeight stores the \"other-pane-height\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.OtherPaneHeight] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5714,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetOtherPaneHeight","product":"core","slug":"tmux-window-setotherpaneheight"},{"id":"tmux.GlobalWindowScope.SetOtherPaneHeight","name":"SetOtherPaneHeight","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetOtherPaneHeight stores the \"other-pane-height\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.OtherPaneHeight] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5724,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetOtherPaneHeight","product":"core","slug":"tmux-globalwindowscope-setotherpaneheight"},{"id":"tmux.Window.SetOtherPaneWidth","name":"SetOtherPaneWidth","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetOtherPaneWidth stores the \"other-pane-width\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.OtherPaneWidth] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5732,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetOtherPaneWidth","product":"core","slug":"tmux-window-setotherpanewidth"},{"id":"tmux.GlobalWindowScope.SetOtherPaneWidth","name":"SetOtherPaneWidth","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetOtherPaneWidth stores the \"other-pane-width\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.OtherPaneWidth] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5742,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetOtherPaneWidth","product":"core","slug":"tmux-globalwindowscope-setotherpanewidth"},{"id":"tmux.Window.SetPaneActiveBorderStyle","name":"SetPaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneActiveBorderStyle stores the \"pane-active-border-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneActiveBorderStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5750,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneActiveBorderStyle","product":"core","slug":"tmux-window-setpaneactiveborderstyle"},{"id":"tmux.GlobalWindowScope.SetPaneActiveBorderStyle","name":"SetPaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneActiveBorderStyle stores the \"pane-active-border-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneActiveBorderStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5760,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneActiveBorderStyle","product":"core","slug":"tmux-globalwindowscope-setpaneactiveborderstyle"},{"id":"tmux.Pane.SetPaneActiveBorderStyle","name":"SetPaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneActiveBorderStyle stores the \"pane-active-border-style\" pane option as string (tmux 3.7 or later). Read it with [PaneOptionValues.PaneActiveBorderStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5768,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetPaneActiveBorderStyle","product":"core","slug":"tmux-pane-setpaneactiveborderstyle"},{"id":"tmux.Window.SetPaneBaseIndex","name":"SetPaneBaseIndex","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetPaneBaseIndex stores the \"pane-base-index\" window option as int64 (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBaseIndex] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5778,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneBaseIndex","product":"core","slug":"tmux-window-setpanebaseindex"},{"id":"tmux.GlobalWindowScope.SetPaneBaseIndex","name":"SetPaneBaseIndex","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetPaneBaseIndex stores the \"pane-base-index\" window option as int64 (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBaseIndex] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5788,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneBaseIndex","product":"core","slug":"tmux-globalwindowscope-setpanebaseindex"},{"id":"tmux.Window.SetPaneBorderFormat","name":"SetPaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderFormat stores the \"pane-border-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5796,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneBorderFormat","product":"core","slug":"tmux-window-setpaneborderformat"},{"id":"tmux.GlobalWindowScope.SetPaneBorderFormat","name":"SetPaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderFormat stores the \"pane-border-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5806,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderFormat","product":"core","slug":"tmux-globalwindowscope-setpaneborderformat"},{"id":"tmux.Pane.SetPaneBorderFormat","name":"SetPaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderFormat stores the \"pane-border-format\" pane option as string (tmux 3.3 or later). Read it with [PaneOptionValues.PaneBorderFormat] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5814,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetPaneBorderFormat","product":"core","slug":"tmux-pane-setpaneborderformat"},{"id":"tmux.Window.SetPaneBorderIndicators","name":"SetPaneBorderIndicators","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderIndicators"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderIndicators stores the \"pane-border-indicators\" window option as PaneBorderIndicators (tmux 3.3 or later). Read it with [WindowOptionValues.PaneBorderIndicators] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5824,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneBorderIndicators","product":"core","slug":"tmux-window-setpaneborderindicators"},{"id":"tmux.GlobalWindowScope.SetPaneBorderIndicators","name":"SetPaneBorderIndicators","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderIndicators"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderIndicators stores the \"pane-border-indicators\" window option as PaneBorderIndicators (tmux 3.3 or later). Read it with [WindowOptionValues.PaneBorderIndicators] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5834,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderIndicators","product":"core","slug":"tmux-globalwindowscope-setpaneborderindicators"},{"id":"tmux.Window.SetPaneBorderLines","name":"SetPaneBorderLines","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderLines"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderLines stores the \"pane-border-lines\" window option as PaneBorderLines (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderLines] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5842,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneBorderLines","product":"core","slug":"tmux-window-setpaneborderlines"},{"id":"tmux.GlobalWindowScope.SetPaneBorderLines","name":"SetPaneBorderLines","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderLines"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderLines stores the \"pane-border-lines\" window option as PaneBorderLines (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderLines] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5852,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderLines","product":"core","slug":"tmux-globalwindowscope-setpaneborderlines"},{"id":"tmux.Window.SetPaneBorderStatus","name":"SetPaneBorderStatus","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderStatus"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStatus stores the \"pane-border-status\" window option as PaneBorderStatus (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderStatus] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5860,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneBorderStatus","product":"core","slug":"tmux-window-setpaneborderstatus"},{"id":"tmux.GlobalWindowScope.SetPaneBorderStatus","name":"SetPaneBorderStatus","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderStatus"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStatus stores the \"pane-border-status\" window option as PaneBorderStatus (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderStatus] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5870,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderStatus","product":"core","slug":"tmux-globalwindowscope-setpaneborderstatus"},{"id":"tmux.Window.SetPaneBorderStyle","name":"SetPaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStyle stores the \"pane-border-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5878,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneBorderStyle","product":"core","slug":"tmux-window-setpaneborderstyle"},{"id":"tmux.GlobalWindowScope.SetPaneBorderStyle","name":"SetPaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStyle stores the \"pane-border-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5888,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderStyle","product":"core","slug":"tmux-globalwindowscope-setpaneborderstyle"},{"id":"tmux.Pane.SetPaneBorderStyle","name":"SetPaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStyle stores the \"pane-border-style\" pane option as string (tmux 3.7 or later). Read it with [PaneOptionValues.PaneBorderStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5896,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetPaneBorderStyle","product":"core","slug":"tmux-pane-setpaneborderstyle"},{"id":"tmux.Window.SetPaneScrollbars","name":"SetPaneScrollbars","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneScrollbars"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbars stores the \"pane-scrollbars\" window option as PaneScrollbars (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbars] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5906,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneScrollbars","product":"core","slug":"tmux-window-setpanescrollbars"},{"id":"tmux.GlobalWindowScope.SetPaneScrollbars","name":"SetPaneScrollbars","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneScrollbars"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbars stores the \"pane-scrollbars\" window option as PaneScrollbars (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbars] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5916,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneScrollbars","product":"core","slug":"tmux-globalwindowscope-setpanescrollbars"},{"id":"tmux.Window.SetPaneScrollbarsPosition","name":"SetPaneScrollbarsPosition","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneScrollbarsPosition"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsPosition stores the \"pane-scrollbars-position\" window option as PaneScrollbarsPosition (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbarsPosition] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5924,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneScrollbarsPosition","product":"core","slug":"tmux-window-setpanescrollbarsposition"},{"id":"tmux.GlobalWindowScope.SetPaneScrollbarsPosition","name":"SetPaneScrollbarsPosition","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneScrollbarsPosition"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsPosition stores the \"pane-scrollbars-position\" window option as PaneScrollbarsPosition (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbarsPosition] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5934,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneScrollbarsPosition","product":"core","slug":"tmux-globalwindowscope-setpanescrollbarsposition"},{"id":"tmux.Window.SetPaneScrollbarsStyle","name":"SetPaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsStyle stores the \"pane-scrollbars-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbarsStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5942,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneScrollbarsStyle","product":"core","slug":"tmux-window-setpanescrollbarsstyle"},{"id":"tmux.GlobalWindowScope.SetPaneScrollbarsStyle","name":"SetPaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsStyle stores the \"pane-scrollbars-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbarsStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5952,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneScrollbarsStyle","product":"core","slug":"tmux-globalwindowscope-setpanescrollbarsstyle"},{"id":"tmux.Pane.SetPaneScrollbarsStyle","name":"SetPaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsStyle stores the \"pane-scrollbars-style\" pane option as string (tmux 3.6 or later). Read it with [PaneOptionValues.PaneScrollbarsStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5960,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetPaneScrollbarsStyle","product":"core","slug":"tmux-pane-setpanescrollbarsstyle"},{"id":"tmux.Window.SetPaneStatusCurrentStyle","name":"SetPaneStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneStatusCurrentStyle stores the \"pane-status-current-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneStatusCurrentStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5970,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneStatusCurrentStyle","product":"core","slug":"tmux-window-setpanestatuscurrentstyle"},{"id":"tmux.GlobalWindowScope.SetPaneStatusCurrentStyle","name":"SetPaneStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneStatusCurrentStyle stores the \"pane-status-current-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneStatusCurrentStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5980,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneStatusCurrentStyle","product":"core","slug":"tmux-globalwindowscope-setpanestatuscurrentstyle"},{"id":"tmux.Window.SetPaneStatusStyle","name":"SetPaneStatusStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneStatusStyle stores the \"pane-status-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneStatusStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5988,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneStatusStyle","product":"core","slug":"tmux-window-setpanestatusstyle"},{"id":"tmux.GlobalWindowScope.SetPaneStatusStyle","name":"SetPaneStatusStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneStatusStyle stores the \"pane-status-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneStatusStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5998,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneStatusStyle","product":"core","slug":"tmux-globalwindowscope-setpanestatusstyle"},{"id":"tmux.Window.SetPopupBorderLines","name":"SetPopupBorderLines","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PopupBorderLines"}],"returns":"error"}],"doc":{"summary":"SetPopupBorderLines stores the \"popup-border-lines\" window option as PopupBorderLines (tmux 3.3 or later). Read it with [WindowOptionValues.PopupBorderLines] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6006,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPopupBorderLines","product":"core","slug":"tmux-window-setpopupborderlines"},{"id":"tmux.GlobalWindowScope.SetPopupBorderLines","name":"SetPopupBorderLines","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PopupBorderLines"}],"returns":"error"}],"doc":{"summary":"SetPopupBorderLines stores the \"popup-border-lines\" window option as PopupBorderLines (tmux 3.3 or later). Read it with [WindowOptionValues.PopupBorderLines] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6016,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPopupBorderLines","product":"core","slug":"tmux-globalwindowscope-setpopupborderlines"},{"id":"tmux.Window.SetPopupBorderStyle","name":"SetPopupBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPopupBorderStyle stores the \"popup-border-style\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.PopupBorderStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6024,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPopupBorderStyle","product":"core","slug":"tmux-window-setpopupborderstyle"},{"id":"tmux.GlobalWindowScope.SetPopupBorderStyle","name":"SetPopupBorderStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPopupBorderStyle stores the \"popup-border-style\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.PopupBorderStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6034,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPopupBorderStyle","product":"core","slug":"tmux-globalwindowscope-setpopupborderstyle"},{"id":"tmux.Window.SetPopupStyle","name":"SetPopupStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPopupStyle stores the \"popup-style\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.PopupStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6042,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPopupStyle","product":"core","slug":"tmux-window-setpopupstyle"},{"id":"tmux.GlobalWindowScope.SetPopupStyle","name":"SetPopupStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPopupStyle stores the \"popup-style\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.PopupStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6052,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPopupStyle","product":"core","slug":"tmux-globalwindowscope-setpopupstyle"},{"id":"tmux.Session.SetPrefix","name":"SetPrefix","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPrefix stores the \"prefix\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.Prefix] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6060,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetPrefix","product":"core","slug":"tmux-session-setprefix"},{"id":"tmux.GlobalSessionScope.SetPrefix","name":"SetPrefix","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPrefix stores the \"prefix\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.Prefix] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6070,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetPrefix","product":"core","slug":"tmux-globalsessionscope-setprefix"},{"id":"tmux.Server.SetPrefixTimeout","name":"SetPrefixTimeout","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetPrefixTimeout stores the \"prefix-timeout\" server option as time.Duration (tmux 3.5 or later). Read it with [ServerOptionValues.PrefixTimeout] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6078,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetPrefixTimeout","product":"core","slug":"tmux-server-setprefixtimeout"},{"id":"tmux.Session.SetPrefix2","name":"SetPrefix2","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPrefix2 stores the \"prefix2\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.Prefix2] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6090,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetPrefix2","product":"core","slug":"tmux-session-setprefix2"},{"id":"tmux.GlobalSessionScope.SetPrefix2","name":"SetPrefix2","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPrefix2 stores the \"prefix2\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.Prefix2] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetPrefix2","product":"core","slug":"tmux-globalsessionscope-setprefix2"},{"id":"tmux.Session.SetPromptCommandCursorStyle","name":"SetPromptCommandCursorStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PromptCommandCursorStyle"}],"returns":"error"}],"doc":{"summary":"SetPromptCommandCursorStyle stores the \"prompt-command-cursor-style\" session option as PromptCommandCursorStyle (tmux 3.7 or later). Read it with [SessionOptionValues.PromptCommandCursorStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetPromptCommandCursorStyle","product":"core","slug":"tmux-session-setpromptcommandcursorstyle"},{"id":"tmux.GlobalSessionScope.SetPromptCommandCursorStyle","name":"SetPromptCommandCursorStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PromptCommandCursorStyle"}],"returns":"error"}],"doc":{"summary":"SetPromptCommandCursorStyle stores the \"prompt-command-cursor-style\" session option as PromptCommandCursorStyle (tmux 3.7 or later). Read it with [SessionOptionValues.PromptCommandCursorStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetPromptCommandCursorStyle","product":"core","slug":"tmux-globalsessionscope-setpromptcommandcursorstyle"},{"id":"tmux.Session.SetPromptCursorColour","name":"SetPromptCursorColour","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPromptCursorColour stores the \"prompt-cursor-colour\" session option as string (tmux 3.6 or later). Read it with [SessionOptionValues.PromptCursorColour] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6126,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetPromptCursorColour","product":"core","slug":"tmux-session-setpromptcursorcolour"},{"id":"tmux.GlobalSessionScope.SetPromptCursorColour","name":"SetPromptCursorColour","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPromptCursorColour stores the \"prompt-cursor-colour\" session option as string (tmux 3.6 or later). Read it with [SessionOptionValues.PromptCursorColour] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6136,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetPromptCursorColour","product":"core","slug":"tmux-globalsessionscope-setpromptcursorcolour"},{"id":"tmux.Session.SetPromptCursorStyle","name":"SetPromptCursorStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PromptCursorStyle"}],"returns":"error"}],"doc":{"summary":"SetPromptCursorStyle stores the \"prompt-cursor-style\" session option as PromptCursorStyle (tmux 3.6 or later). Read it with [SessionOptionValues.PromptCursorStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6144,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetPromptCursorStyle","product":"core","slug":"tmux-session-setpromptcursorstyle"},{"id":"tmux.GlobalSessionScope.SetPromptCursorStyle","name":"SetPromptCursorStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PromptCursorStyle"}],"returns":"error"}],"doc":{"summary":"SetPromptCursorStyle stores the \"prompt-cursor-style\" session option as PromptCursorStyle (tmux 3.6 or later). Read it with [SessionOptionValues.PromptCursorStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6154,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetPromptCursorStyle","product":"core","slug":"tmux-globalsessionscope-setpromptcursorstyle"},{"id":"tmux.Server.SetPromptHistoryLimit","name":"SetPromptHistoryLimit","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetPromptHistoryLimit stores the \"prompt-history-limit\" server option as int64 (tmux 3.3 or later). Read it with [ServerOptionValues.PromptHistoryLimit] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6162,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetPromptHistoryLimit","product":"core","slug":"tmux-server-setprompthistorylimit"},{"id":"tmux.Window.SetRemainOnExit","name":"SetRemainOnExit","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"RemainOnExit"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExit stores the \"remain-on-exit\" window option as RemainOnExit (tmux 3.2a or later). Read it with [WindowOptionValues.RemainOnExit] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6170,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetRemainOnExit","product":"core","slug":"tmux-window-setremainonexit"},{"id":"tmux.GlobalWindowScope.SetRemainOnExit","name":"SetRemainOnExit","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"RemainOnExit"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExit stores the \"remain-on-exit\" window option as RemainOnExit (tmux 3.2a or later). Read it with [WindowOptionValues.RemainOnExit] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6180,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetRemainOnExit","product":"core","slug":"tmux-globalwindowscope-setremainonexit"},{"id":"tmux.Pane.SetRemainOnExit","name":"SetRemainOnExit","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"RemainOnExit"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExit stores the \"remain-on-exit\" pane option as RemainOnExit (tmux 3.2a or later). Read it with [PaneOptionValues.RemainOnExit] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6188,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetRemainOnExit","product":"core","slug":"tmux-pane-setremainonexit"},{"id":"tmux.Window.SetRemainOnExitFormat","name":"SetRemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExitFormat stores the \"remain-on-exit-format\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.RemainOnExitFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6198,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetRemainOnExitFormat","product":"core","slug":"tmux-window-setremainonexitformat"},{"id":"tmux.GlobalWindowScope.SetRemainOnExitFormat","name":"SetRemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExitFormat stores the \"remain-on-exit-format\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.RemainOnExitFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6208,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetRemainOnExitFormat","product":"core","slug":"tmux-globalwindowscope-setremainonexitformat"},{"id":"tmux.Pane.SetRemainOnExitFormat","name":"SetRemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExitFormat stores the \"remain-on-exit-format\" pane option as string (tmux 3.3 or later). Read it with [PaneOptionValues.RemainOnExitFormat] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6216,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetRemainOnExitFormat","product":"core","slug":"tmux-pane-setremainonexitformat"},{"id":"tmux.Session.SetRenumberWindows","name":"SetRenumberWindows","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetRenumberWindows stores the \"renumber-windows\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.RenumberWindows] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6226,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetRenumberWindows","product":"core","slug":"tmux-session-setrenumberwindows"},{"id":"tmux.GlobalSessionScope.SetRenumberWindows","name":"SetRenumberWindows","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetRenumberWindows stores the \"renumber-windows\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.RenumberWindows] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6236,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetRenumberWindows","product":"core","slug":"tmux-globalsessionscope-setrenumberwindows"},{"id":"tmux.Session.SetRepeatTime","name":"SetRepeatTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetRepeatTime stores the \"repeat-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.RepeatTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6244,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetRepeatTime","product":"core","slug":"tmux-session-setrepeattime"},{"id":"tmux.GlobalSessionScope.SetRepeatTime","name":"SetRepeatTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetRepeatTime stores the \"repeat-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.RepeatTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6258,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetRepeatTime","product":"core","slug":"tmux-globalsessionscope-setrepeattime"},{"id":"tmux.Window.SetScrollOnClear","name":"SetScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetScrollOnClear stores the \"scroll-on-clear\" window option as bool (tmux 3.3 or later). Read it with [WindowOptionValues.ScrollOnClear] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6270,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetScrollOnClear","product":"core","slug":"tmux-window-setscrollonclear"},{"id":"tmux.GlobalWindowScope.SetScrollOnClear","name":"SetScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetScrollOnClear stores the \"scroll-on-clear\" window option as bool (tmux 3.3 or later). Read it with [WindowOptionValues.ScrollOnClear] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6280,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetScrollOnClear","product":"core","slug":"tmux-globalwindowscope-setscrollonclear"},{"id":"tmux.Pane.SetScrollOnClear","name":"SetScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetScrollOnClear stores the \"scroll-on-clear\" pane option as bool (tmux 3.3 or later). Read it with [PaneOptionValues.ScrollOnClear] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6288,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetScrollOnClear","product":"core","slug":"tmux-pane-setscrollonclear"},{"id":"tmux.Window.SetSessionStatusCurrentStyle","name":"SetSessionStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetSessionStatusCurrentStyle stores the \"session-status-current-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.SessionStatusCurrentStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6298,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetSessionStatusCurrentStyle","product":"core","slug":"tmux-window-setsessionstatuscurrentstyle"},{"id":"tmux.GlobalWindowScope.SetSessionStatusCurrentStyle","name":"SetSessionStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetSessionStatusCurrentStyle stores the \"session-status-current-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.SessionStatusCurrentStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6308,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetSessionStatusCurrentStyle","product":"core","slug":"tmux-globalwindowscope-setsessionstatuscurrentstyle"},{"id":"tmux.Window.SetSessionStatusStyle","name":"SetSessionStatusStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetSessionStatusStyle stores the \"session-status-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.SessionStatusStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6316,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetSessionStatusStyle","product":"core","slug":"tmux-window-setsessionstatusstyle"},{"id":"tmux.GlobalWindowScope.SetSessionStatusStyle","name":"SetSessionStatusStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetSessionStatusStyle stores the \"session-status-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.SessionStatusStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6326,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetSessionStatusStyle","product":"core","slug":"tmux-globalwindowscope-setsessionstatusstyle"},{"id":"tmux.Server.SetClipboard","name":"SetClipboard","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SetClipboard"}],"returns":"error"}],"doc":{"summary":"SetClipboard stores the \"set-clipboard\" server option as SetClipboard (tmux 3.2a or later). Read it with [ServerOptionValues.SetClipboard] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6334,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetClipboard","product":"core","slug":"tmux-server-setclipboard"},{"id":"tmux.Session.SetTitles","name":"SetTitles","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetTitles stores the \"set-titles\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.SetTitles] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6342,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetTitles","product":"core","slug":"tmux-session-settitles"},{"id":"tmux.GlobalSessionScope.SetTitles","name":"SetTitles","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetTitles stores the \"set-titles\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.SetTitles] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6352,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetTitles","product":"core","slug":"tmux-globalsessionscope-settitles"},{"id":"tmux.Session.SetTitlesString","name":"SetTitlesString","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTitlesString stores the \"set-titles-string\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.SetTitlesString] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6360,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetTitlesString","product":"core","slug":"tmux-session-settitlesstring"},{"id":"tmux.GlobalSessionScope.SetTitlesString","name":"SetTitlesString","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTitlesString stores the \"set-titles-string\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.SetTitlesString] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6370,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetTitlesString","product":"core","slug":"tmux-globalsessionscope-settitlesstring"},{"id":"tmux.Session.SetSilenceAction","name":"SetSilenceAction","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SilenceAction"}],"returns":"error"}],"doc":{"summary":"SetSilenceAction stores the \"silence-action\" session option as SilenceAction (tmux 3.2a or later). Read it with [SessionOptionValues.SilenceAction] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6378,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetSilenceAction","product":"core","slug":"tmux-session-setsilenceaction"},{"id":"tmux.GlobalSessionScope.SetSilenceAction","name":"SetSilenceAction","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SilenceAction"}],"returns":"error"}],"doc":{"summary":"SetSilenceAction stores the \"silence-action\" session option as SilenceAction (tmux 3.2a or later). Read it with [SessionOptionValues.SilenceAction] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6388,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetSilenceAction","product":"core","slug":"tmux-globalsessionscope-setsilenceaction"},{"id":"tmux.Session.SetStatus","name":"SetStatus","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"Status"}],"returns":"error"}],"doc":{"summary":"SetStatus stores the \"status\" session option as Status (tmux 3.2a or later). Read it with [SessionOptionValues.Status] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6396,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatus","product":"core","slug":"tmux-session-setstatus"},{"id":"tmux.GlobalSessionScope.SetStatus","name":"SetStatus","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"Status"}],"returns":"error"}],"doc":{"summary":"SetStatus stores the \"status\" session option as Status (tmux 3.2a or later). Read it with [SessionOptionValues.Status] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6406,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatus","product":"core","slug":"tmux-globalsessionscope-setstatus"},{"id":"tmux.Session.SetStatusBG","name":"SetStatusBG","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusBG stores the \"status-bg\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusBG] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6414,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusBG","product":"core","slug":"tmux-session-setstatusbg"},{"id":"tmux.GlobalSessionScope.SetStatusBG","name":"SetStatusBG","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusBG stores the \"status-bg\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusBG] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6424,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusBG","product":"core","slug":"tmux-globalsessionscope-setstatusbg"},{"id":"tmux.Session.SetStatusFG","name":"SetStatusFG","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusFG stores the \"status-fg\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusFG] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6432,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusFG","product":"core","slug":"tmux-session-setstatusfg"},{"id":"tmux.GlobalSessionScope.SetStatusFG","name":"SetStatusFG","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusFG stores the \"status-fg\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusFG] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6442,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusFG","product":"core","slug":"tmux-globalsessionscope-setstatusfg"},{"id":"tmux.Session.SetStatusInterval","name":"SetStatusInterval","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetStatusInterval stores the \"status-interval\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.StatusInterval] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6450,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusInterval","product":"core","slug":"tmux-session-setstatusinterval"},{"id":"tmux.GlobalSessionScope.SetStatusInterval","name":"SetStatusInterval","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetStatusInterval stores the \"status-interval\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.StatusInterval] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6464,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusInterval","product":"core","slug":"tmux-globalsessionscope-setstatusinterval"},{"id":"tmux.Session.SetStatusJustify","name":"SetStatusJustify","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusJustify"}],"returns":"error"}],"doc":{"summary":"SetStatusJustify stores the \"status-justify\" session option as StatusJustify (tmux 3.2a or later). Read it with [SessionOptionValues.StatusJustify] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6476,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusJustify","product":"core","slug":"tmux-session-setstatusjustify"},{"id":"tmux.GlobalSessionScope.SetStatusJustify","name":"SetStatusJustify","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusJustify"}],"returns":"error"}],"doc":{"summary":"SetStatusJustify stores the \"status-justify\" session option as StatusJustify (tmux 3.2a or later). Read it with [SessionOptionValues.StatusJustify] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6486,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusJustify","product":"core","slug":"tmux-globalsessionscope-setstatusjustify"},{"id":"tmux.Session.SetStatusKeys","name":"SetStatusKeys","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusKeys"}],"returns":"error"}],"doc":{"summary":"SetStatusKeys stores the \"status-keys\" session option as StatusKeys (tmux 3.2a or later). Read it with [SessionOptionValues.StatusKeys] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6494,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusKeys","product":"core","slug":"tmux-session-setstatuskeys"},{"id":"tmux.GlobalSessionScope.SetStatusKeys","name":"SetStatusKeys","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusKeys"}],"returns":"error"}],"doc":{"summary":"SetStatusKeys stores the \"status-keys\" session option as StatusKeys (tmux 3.2a or later). Read it with [SessionOptionValues.StatusKeys] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6504,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusKeys","product":"core","slug":"tmux-globalsessionscope-setstatuskeys"},{"id":"tmux.Session.SetStatusLeft","name":"SetStatusLeft","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusLeft stores the \"status-left\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeft] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6512,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusLeft","product":"core","slug":"tmux-session-setstatusleft"},{"id":"tmux.GlobalSessionScope.SetStatusLeft","name":"SetStatusLeft","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusLeft stores the \"status-left\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeft] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6522,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusLeft","product":"core","slug":"tmux-globalsessionscope-setstatusleft"},{"id":"tmux.Session.SetStatusLeftLength","name":"SetStatusLeftLength","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetStatusLeftLength stores the \"status-left-length\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeftLength] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6530,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusLeftLength","product":"core","slug":"tmux-session-setstatusleftlength"},{"id":"tmux.GlobalSessionScope.SetStatusLeftLength","name":"SetStatusLeftLength","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetStatusLeftLength stores the \"status-left-length\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeftLength] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6540,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusLeftLength","product":"core","slug":"tmux-globalsessionscope-setstatusleftlength"},{"id":"tmux.Session.SetStatusLeftStyle","name":"SetStatusLeftStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusLeftStyle stores the \"status-left-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeftStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6548,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusLeftStyle","product":"core","slug":"tmux-session-setstatusleftstyle"},{"id":"tmux.GlobalSessionScope.SetStatusLeftStyle","name":"SetStatusLeftStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusLeftStyle stores the \"status-left-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeftStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6558,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusLeftStyle","product":"core","slug":"tmux-globalsessionscope-setstatusleftstyle"},{"id":"tmux.Session.SetStatusPosition","name":"SetStatusPosition","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusPosition"}],"returns":"error"}],"doc":{"summary":"SetStatusPosition stores the \"status-position\" session option as StatusPosition (tmux 3.2a or later). Read it with [SessionOptionValues.StatusPosition] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6566,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusPosition","product":"core","slug":"tmux-session-setstatusposition"},{"id":"tmux.GlobalSessionScope.SetStatusPosition","name":"SetStatusPosition","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusPosition"}],"returns":"error"}],"doc":{"summary":"SetStatusPosition stores the \"status-position\" session option as StatusPosition (tmux 3.2a or later). Read it with [SessionOptionValues.StatusPosition] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6576,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusPosition","product":"core","slug":"tmux-globalsessionscope-setstatusposition"},{"id":"tmux.Session.SetStatusRight","name":"SetStatusRight","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusRight stores the \"status-right\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRight] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6584,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusRight","product":"core","slug":"tmux-session-setstatusright"},{"id":"tmux.GlobalSessionScope.SetStatusRight","name":"SetStatusRight","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusRight stores the \"status-right\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRight] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6594,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusRight","product":"core","slug":"tmux-globalsessionscope-setstatusright"},{"id":"tmux.Session.SetStatusRightLength","name":"SetStatusRightLength","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetStatusRightLength stores the \"status-right-length\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRightLength] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6602,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusRightLength","product":"core","slug":"tmux-session-setstatusrightlength"},{"id":"tmux.GlobalSessionScope.SetStatusRightLength","name":"SetStatusRightLength","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetStatusRightLength stores the \"status-right-length\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRightLength] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6612,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusRightLength","product":"core","slug":"tmux-globalsessionscope-setstatusrightlength"},{"id":"tmux.Session.SetStatusRightStyle","name":"SetStatusRightStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusRightStyle stores the \"status-right-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRightStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6620,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusRightStyle","product":"core","slug":"tmux-session-setstatusrightstyle"},{"id":"tmux.GlobalSessionScope.SetStatusRightStyle","name":"SetStatusRightStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusRightStyle stores the \"status-right-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRightStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6630,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusRightStyle","product":"core","slug":"tmux-globalsessionscope-setstatusrightstyle"},{"id":"tmux.Session.SetStatusStyle","name":"SetStatusStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusStyle stores the \"status-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6638,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusStyle","product":"core","slug":"tmux-session-setstatusstyle"},{"id":"tmux.GlobalSessionScope.SetStatusStyle","name":"SetStatusStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusStyle stores the \"status-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6648,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusStyle","product":"core","slug":"tmux-globalsessionscope-setstatusstyle"},{"id":"tmux.Window.SetSynchronizePanes","name":"SetSynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetSynchronizePanes stores the \"synchronize-panes\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.SynchronizePanes] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6656,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetSynchronizePanes","product":"core","slug":"tmux-window-setsynchronizepanes"},{"id":"tmux.GlobalWindowScope.SetSynchronizePanes","name":"SetSynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetSynchronizePanes stores the \"synchronize-panes\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.SynchronizePanes] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6666,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetSynchronizePanes","product":"core","slug":"tmux-globalwindowscope-setsynchronizepanes"},{"id":"tmux.Pane.SetSynchronizePanes","name":"SetSynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetSynchronizePanes stores the \"synchronize-panes\" pane option as bool (tmux 3.2a or later). Read it with [PaneOptionValues.SynchronizePanes] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6674,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetSynchronizePanes","product":"core","slug":"tmux-pane-setsynchronizepanes"},{"id":"tmux.Window.SetTiledLayoutMaxColumns","name":"SetTiledLayoutMaxColumns","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetTiledLayoutMaxColumns stores the \"tiled-layout-max-columns\" window option as int64 (tmux 3.6 or later). Read it with [WindowOptionValues.TiledLayoutMaxColumns] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6684,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetTiledLayoutMaxColumns","product":"core","slug":"tmux-window-settiledlayoutmaxcolumns"},{"id":"tmux.GlobalWindowScope.SetTiledLayoutMaxColumns","name":"SetTiledLayoutMaxColumns","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetTiledLayoutMaxColumns stores the \"tiled-layout-max-columns\" window option as int64 (tmux 3.6 or later). Read it with [WindowOptionValues.TiledLayoutMaxColumns] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6694,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetTiledLayoutMaxColumns","product":"core","slug":"tmux-globalwindowscope-settiledlayoutmaxcolumns"},{"id":"tmux.Window.SetTreeModePreviewFormat","name":"SetTreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewFormat stores the \"tree-mode-preview-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.TreeModePreviewFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6702,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetTreeModePreviewFormat","product":"core","slug":"tmux-window-settreemodepreviewformat"},{"id":"tmux.GlobalWindowScope.SetTreeModePreviewFormat","name":"SetTreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewFormat stores the \"tree-mode-preview-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.TreeModePreviewFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6712,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetTreeModePreviewFormat","product":"core","slug":"tmux-globalwindowscope-settreemodepreviewformat"},{"id":"tmux.Pane.SetTreeModePreviewFormat","name":"SetTreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewFormat stores the \"tree-mode-preview-format\" pane option as string (tmux 3.7 or later). Read it with [PaneOptionValues.TreeModePreviewFormat] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6720,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetTreeModePreviewFormat","product":"core","slug":"tmux-pane-settreemodepreviewformat"},{"id":"tmux.Window.SetTreeModePreviewStyle","name":"SetTreeModePreviewStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewStyle stores the \"tree-mode-preview-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.TreeModePreviewStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6730,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetTreeModePreviewStyle","product":"core","slug":"tmux-window-settreemodepreviewstyle"},{"id":"tmux.GlobalWindowScope.SetTreeModePreviewStyle","name":"SetTreeModePreviewStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewStyle stores the \"tree-mode-preview-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.TreeModePreviewStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6740,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetTreeModePreviewStyle","product":"core","slug":"tmux-globalwindowscope-settreemodepreviewstyle"},{"id":"tmux.Server.SetVariationSelectorAlwaysWide","name":"SetVariationSelectorAlwaysWide","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetVariationSelectorAlwaysWide stores the \"variation-selector-always-wide\" server option as bool (tmux 3.6 or later). Read it with [ServerOptionValues.VariationSelectorAlwaysWide] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6748,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetVariationSelectorAlwaysWide","product":"core","slug":"tmux-server-setvariationselectoralwayswide"},{"id":"tmux.Session.SetVisualActivity","name":"SetVisualActivity","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualActivity"}],"returns":"error"}],"doc":{"summary":"SetVisualActivity stores the \"visual-activity\" session option as VisualActivity (tmux 3.2a or later). Read it with [SessionOptionValues.VisualActivity] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6756,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetVisualActivity","product":"core","slug":"tmux-session-setvisualactivity"},{"id":"tmux.GlobalSessionScope.SetVisualActivity","name":"SetVisualActivity","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualActivity"}],"returns":"error"}],"doc":{"summary":"SetVisualActivity stores the \"visual-activity\" session option as VisualActivity (tmux 3.2a or later). Read it with [SessionOptionValues.VisualActivity] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6766,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetVisualActivity","product":"core","slug":"tmux-globalsessionscope-setvisualactivity"},{"id":"tmux.Session.SetVisualBell","name":"SetVisualBell","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualBell"}],"returns":"error"}],"doc":{"summary":"SetVisualBell stores the \"visual-bell\" session option as VisualBell (tmux 3.2a or later). Read it with [SessionOptionValues.VisualBell] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6774,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetVisualBell","product":"core","slug":"tmux-session-setvisualbell"},{"id":"tmux.GlobalSessionScope.SetVisualBell","name":"SetVisualBell","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualBell"}],"returns":"error"}],"doc":{"summary":"SetVisualBell stores the \"visual-bell\" session option as VisualBell (tmux 3.2a or later). Read it with [SessionOptionValues.VisualBell] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6784,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetVisualBell","product":"core","slug":"tmux-globalsessionscope-setvisualbell"},{"id":"tmux.Session.SetVisualSilence","name":"SetVisualSilence","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualSilence"}],"returns":"error"}],"doc":{"summary":"SetVisualSilence stores the \"visual-silence\" session option as VisualSilence (tmux 3.2a or later). Read it with [SessionOptionValues.VisualSilence] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6792,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetVisualSilence","product":"core","slug":"tmux-session-setvisualsilence"},{"id":"tmux.GlobalSessionScope.SetVisualSilence","name":"SetVisualSilence","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualSilence"}],"returns":"error"}],"doc":{"summary":"SetVisualSilence stores the \"visual-silence\" session option as VisualSilence (tmux 3.2a or later). Read it with [SessionOptionValues.VisualSilence] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6802,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetVisualSilence","product":"core","slug":"tmux-globalsessionscope-setvisualsilence"},{"id":"tmux.Window.SetWindowActiveStyle","name":"SetWindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowActiveStyle stores the \"window-active-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowActiveStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6810,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowActiveStyle","product":"core","slug":"tmux-window-setwindowactivestyle"},{"id":"tmux.GlobalWindowScope.SetWindowActiveStyle","name":"SetWindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowActiveStyle stores the \"window-active-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowActiveStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6820,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowActiveStyle","product":"core","slug":"tmux-globalwindowscope-setwindowactivestyle"},{"id":"tmux.Pane.SetWindowActiveStyle","name":"SetWindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowActiveStyle stores the \"window-active-style\" pane option as string (tmux 3.2a or later). Read it with [PaneOptionValues.WindowActiveStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6828,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetWindowActiveStyle","product":"core","slug":"tmux-pane-setwindowactivestyle"},{"id":"tmux.Window.SetWindowPaneCurrentStatusFormat","name":"SetWindowPaneCurrentStatusFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowPaneCurrentStatusFormat stores the \"window-pane-current-status-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.WindowPaneCurrentStatusFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6838,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowPaneCurrentStatusFormat","product":"core","slug":"tmux-window-setwindowpanecurrentstatusformat"},{"id":"tmux.GlobalWindowScope.SetWindowPaneCurrentStatusFormat","name":"SetWindowPaneCurrentStatusFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowPaneCurrentStatusFormat stores the \"window-pane-current-status-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.WindowPaneCurrentStatusFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6848,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowPaneCurrentStatusFormat","product":"core","slug":"tmux-globalwindowscope-setwindowpanecurrentstatusformat"},{"id":"tmux.Window.SetWindowPaneStatusFormat","name":"SetWindowPaneStatusFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowPaneStatusFormat stores the \"window-pane-status-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.WindowPaneStatusFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6856,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowPaneStatusFormat","product":"core","slug":"tmux-window-setwindowpanestatusformat"},{"id":"tmux.GlobalWindowScope.SetWindowPaneStatusFormat","name":"SetWindowPaneStatusFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowPaneStatusFormat stores the \"window-pane-status-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.WindowPaneStatusFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6866,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowPaneStatusFormat","product":"core","slug":"tmux-globalwindowscope-setwindowpanestatusformat"},{"id":"tmux.Window.SetWindowSize","name":"SetWindowSize","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"WindowSize"}],"returns":"error"}],"doc":{"summary":"SetWindowSize stores the \"window-size\" window option as WindowSize (tmux 3.2a or later). Read it with [WindowOptionValues.WindowSize] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6874,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowSize","product":"core","slug":"tmux-window-setwindowsize"},{"id":"tmux.GlobalWindowScope.SetWindowSize","name":"SetWindowSize","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"WindowSize"}],"returns":"error"}],"doc":{"summary":"SetWindowSize stores the \"window-size\" window option as WindowSize (tmux 3.2a or later). Read it with [WindowOptionValues.WindowSize] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6884,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowSize","product":"core","slug":"tmux-globalwindowscope-setwindowsize"},{"id":"tmux.Window.SetWindowStatusActivityStyle","name":"SetWindowStatusActivityStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusActivityStyle stores the \"window-status-activity-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusActivityStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6892,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStatusActivityStyle","product":"core","slug":"tmux-window-setwindowstatusactivitystyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusActivityStyle","name":"SetWindowStatusActivityStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusActivityStyle stores the \"window-status-activity-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusActivityStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6902,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusActivityStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatusactivitystyle"},{"id":"tmux.Window.SetWindowStatusBellStyle","name":"SetWindowStatusBellStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusBellStyle stores the \"window-status-bell-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusBellStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6910,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStatusBellStyle","product":"core","slug":"tmux-window-setwindowstatusbellstyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusBellStyle","name":"SetWindowStatusBellStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusBellStyle stores the \"window-status-bell-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusBellStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6920,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusBellStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatusbellstyle"},{"id":"tmux.Window.SetWindowStatusCurrentFormat","name":"SetWindowStatusCurrentFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusCurrentFormat stores the \"window-status-current-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusCurrentFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6928,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStatusCurrentFormat","product":"core","slug":"tmux-window-setwindowstatuscurrentformat"},{"id":"tmux.GlobalWindowScope.SetWindowStatusCurrentFormat","name":"SetWindowStatusCurrentFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusCurrentFormat stores the \"window-status-current-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusCurrentFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6938,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusCurrentFormat","product":"core","slug":"tmux-globalwindowscope-setwindowstatuscurrentformat"},{"id":"tmux.Window.SetWindowStatusCurrentStyle","name":"SetWindowStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusCurrentStyle stores the \"window-status-current-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusCurrentStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6946,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStatusCurrentStyle","product":"core","slug":"tmux-window-setwindowstatuscurrentstyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusCurrentStyle","name":"SetWindowStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusCurrentStyle stores the \"window-status-current-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusCurrentStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6956,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusCurrentStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatuscurrentstyle"},{"id":"tmux.Window.SetWindowStatusFormat","name":"SetWindowStatusFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusFormat stores the \"window-status-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6964,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStatusFormat","product":"core","slug":"tmux-window-setwindowstatusformat"},{"id":"tmux.GlobalWindowScope.SetWindowStatusFormat","name":"SetWindowStatusFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusFormat stores the \"window-status-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6974,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusFormat","product":"core","slug":"tmux-globalwindowscope-setwindowstatusformat"},{"id":"tmux.Window.SetWindowStatusLastStyle","name":"SetWindowStatusLastStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusLastStyle stores the \"window-status-last-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusLastStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6982,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStatusLastStyle","product":"core","slug":"tmux-window-setwindowstatuslaststyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusLastStyle","name":"SetWindowStatusLastStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusLastStyle stores the \"window-status-last-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusLastStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6992,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusLastStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatuslaststyle"},{"id":"tmux.Window.SetWindowStatusSeparator","name":"SetWindowStatusSeparator","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusSeparator stores the \"window-status-separator\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusSeparator] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7000,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStatusSeparator","product":"core","slug":"tmux-window-setwindowstatusseparator"},{"id":"tmux.GlobalWindowScope.SetWindowStatusSeparator","name":"SetWindowStatusSeparator","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusSeparator stores the \"window-status-separator\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusSeparator] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7010,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusSeparator","product":"core","slug":"tmux-globalwindowscope-setwindowstatusseparator"},{"id":"tmux.Window.SetWindowStatusStyle","name":"SetWindowStatusStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusStyle stores the \"window-status-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7018,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStatusStyle","product":"core","slug":"tmux-window-setwindowstatusstyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusStyle","name":"SetWindowStatusStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusStyle stores the \"window-status-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7028,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatusstyle"},{"id":"tmux.Window.SetWindowStyle","name":"SetWindowStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStyle stores the \"window-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7036,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWindowStyle","product":"core","slug":"tmux-window-setwindowstyle"},{"id":"tmux.GlobalWindowScope.SetWindowStyle","name":"SetWindowStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStyle stores the \"window-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7046,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWindowStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstyle"},{"id":"tmux.Pane.SetWindowStyle","name":"SetWindowStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStyle stores the \"window-style\" pane option as string (tmux 3.2a or later). Read it with [PaneOptionValues.WindowStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7054,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetWindowStyle","product":"core","slug":"tmux-pane-setwindowstyle"},{"id":"tmux.Session.SetWordSeparators","name":"SetWordSeparators","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWordSeparators stores the \"word-separators\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.WordSeparators] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7064,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetWordSeparators","product":"core","slug":"tmux-session-setwordseparators"},{"id":"tmux.GlobalSessionScope.SetWordSeparators","name":"SetWordSeparators","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWordSeparators stores the \"word-separators\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.WordSeparators] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7074,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetWordSeparators","product":"core","slug":"tmux-globalsessionscope-setwordseparators"},{"id":"tmux.Window.SetWrapSearch","name":"SetWrapSearch","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetWrapSearch stores the \"wrap-search\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.WrapSearch] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7082,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetWrapSearch","product":"core","slug":"tmux-window-setwrapsearch"},{"id":"tmux.GlobalWindowScope.SetWrapSearch","name":"SetWrapSearch","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetWrapSearch stores the \"wrap-search\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.WrapSearch] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7092,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetWrapSearch","product":"core","slug":"tmux-globalwindowscope-setwrapsearch"},{"id":"tmux.Window.SetXTermKeys","name":"SetXTermKeys","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetXTermKeys stores the \"xterm-keys\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.XTermKeys] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetXTermKeys","product":"core","slug":"tmux-window-setxtermkeys"},{"id":"tmux.GlobalWindowScope.SetXTermKeys","name":"SetXTermKeys","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetXTermKeys stores the \"xterm-keys\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.XTermKeys] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7110,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetXTermKeys","product":"core","slug":"tmux-globalwindowscope-setxtermkeys"},{"id":"tmux.Server.SetCodepointWidths","name":"SetCodepointWidths","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetCodepointWidths replaces the complete \"codepoint-widths\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.6 or later). Read it with [ServerOptionValues.CodepointWidths] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7119,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetCodepointWidths","product":"core","slug":"tmux-server-setcodepointwidths"},{"id":"tmux.Server.SetCommandAlias","name":"SetCommandAlias","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetCommandAlias replaces the complete \"command-alias\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [ServerOptionValues.CommandAlias] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7128,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetCommandAlias","product":"core","slug":"tmux-server-setcommandalias"},{"id":"tmux.Window.SetPaneColours","name":"SetPaneColours","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetPaneColours replaces the complete \"pane-colours\" window option array with SparseArray[string], preserving holes and empty values (tmux 3.3 or later). Read it with [WindowOptionValues.PaneColours] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7137,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetPaneColours","product":"core","slug":"tmux-window-setpanecolours"},{"id":"tmux.GlobalWindowScope.SetPaneColours","name":"SetPaneColours","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetPaneColours replaces the complete \"pane-colours\" window option array with SparseArray[string], preserving holes and empty values (tmux 3.3 or later). Read it with [WindowOptionValues.PaneColours] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7148,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetPaneColours","product":"core","slug":"tmux-globalwindowscope-setpanecolours"},{"id":"tmux.Pane.SetPaneColours","name":"SetPaneColours","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetPaneColours replaces the complete \"pane-colours\" pane option array with SparseArray[string], preserving holes and empty values (tmux 3.3 or later). Read it with [PaneOptionValues.PaneColours] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7157,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetPaneColours","product":"core","slug":"tmux-pane-setpanecolours"},{"id":"tmux.Session.SetStatusFormat","name":"SetStatusFormat","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetStatusFormat replaces the complete \"status-format\" session option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [SessionOptionValues.StatusFormat] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7168,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetStatusFormat","product":"core","slug":"tmux-session-setstatusformat"},{"id":"tmux.GlobalSessionScope.SetStatusFormat","name":"SetStatusFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetStatusFormat replaces the complete \"status-format\" session option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [SessionOptionValues.StatusFormat] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7179,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetStatusFormat","product":"core","slug":"tmux-globalsessionscope-setstatusformat"},{"id":"tmux.Server.SetTerminalFeatures","name":"SetTerminalFeatures","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetTerminalFeatures replaces the complete \"terminal-features\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [ServerOptionValues.TerminalFeatures] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7188,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetTerminalFeatures","product":"core","slug":"tmux-server-setterminalfeatures"},{"id":"tmux.Server.SetTerminalOverrides","name":"SetTerminalOverrides","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetTerminalOverrides replaces the complete \"terminal-overrides\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [ServerOptionValues.TerminalOverrides] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7197,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetTerminalOverrides","product":"core","slug":"tmux-server-setterminaloverrides"},{"id":"tmux.Session.SetUpdateEnvironment","name":"SetUpdateEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetUpdateEnvironment replaces the complete \"update-environment\" session option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [SessionOptionValues.UpdateEnvironment] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7206,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetUpdateEnvironment","product":"core","slug":"tmux-session-setupdateenvironment"},{"id":"tmux.GlobalSessionScope.SetUpdateEnvironment","name":"SetUpdateEnvironment","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetUpdateEnvironment replaces the complete \"update-environment\" session option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [SessionOptionValues.UpdateEnvironment] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7217,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetUpdateEnvironment","product":"core","slug":"tmux-globalsessionscope-setupdateenvironment"},{"id":"tmux.Server.SetUserKeys","name":"SetUserKeys","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetUserKeys replaces the complete \"user-keys\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [ServerOptionValues.UserKeys] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7226,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetUserKeys","product":"core","slug":"tmux-server-setuserkeys"},{"id":"tmux.SetOptionOptions","name":"SetOptionOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetOptionOptions controls set-option mutation flags. Its zero value sends no optional mutation flags."},"source":{"file":"tmux/option_mutation.go","line":7,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetOptionOptions","product":"core","slug":"tmux-setoptionoptions"},{"id":"tmux.SetOptionOptions.ExpandFormat","name":"ExpandFormat","kind":"attribute","modifiers":[],"parent":"tmux.SetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"ExpandFormat expands tmux formats in the value before storing it."},"source":{"file":"tmux/option_mutation.go","line":9,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetOptionOptions.ExpandFormat","product":"core","slug":"tmux-setoptionoptions-expandformat"},{"id":"tmux.SetOptionOptions.PreventOverwrite","name":"PreventOverwrite","kind":"attribute","modifiers":[],"parent":"tmux.SetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"PreventOverwrite leaves an existing option unchanged."},"source":{"file":"tmux/option_mutation.go","line":11,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetOptionOptions.PreventOverwrite","product":"core","slug":"tmux-setoptionoptions-preventoverwrite"},{"id":"tmux.SetOptionOptions.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.SetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux's missing-option diagnostic."},"source":{"file":"tmux/option_mutation.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetOptionOptions.Quiet","product":"core","slug":"tmux-setoptionoptions-quiet"},{"id":"tmux.UnsetOptionOptions","name":"UnsetOptionOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"UnsetOptionOptions controls set-option unset behavior. Its zero value unsets only the selected option."},"source":{"file":"tmux/option_mutation.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnsetOptionOptions","product":"core","slug":"tmux-unsetoptionoptions"},{"id":"tmux.UnsetOptionOptions.UnsetPanes","name":"UnsetPanes","kind":"attribute","modifiers":[],"parent":"tmux.UnsetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"UnsetPanes unsets a window option on every pane in a Window receiver."},"source":{"file":"tmux/option_mutation.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnsetOptionOptions.UnsetPanes","product":"core","slug":"tmux-unsetoptionoptions-unsetpanes"},{"id":"tmux.UnsetOptionOptions.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.UnsetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux's missing-option diagnostic."},"source":{"file":"tmux/option_mutation.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnsetOptionOptions.Quiet","product":"core","slug":"tmux-unsetoptionoptions-quiet"},{"id":"tmux.Server.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a server-scope option without refreshing existing models. It may validate a known option against the live version. Completed failures return secret-safe option errors; cancellation does not prove the mutation was not accepted by tmux."},"source":{"file":"tmux/option_mutation.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetOption","product":"core","slug":"tmux-server-setoption"},{"id":"tmux.GlobalSessionScope.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a global session option without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.SetOption","product":"core","slug":"tmux-globalsessionscope-setoption"},{"id":"tmux.GlobalWindowScope.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a global window option without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.SetOption","product":"core","slug":"tmux-globalwindowscope-setoption"},{"id":"tmux.Session.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a session option at this stable session target without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":92,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SetOption","product":"core","slug":"tmux-session-setoption"},{"id":"tmux.Window.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a window option at this exact window target without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SetOption","product":"core","slug":"tmux-window-setoption"},{"id":"tmux.Pane.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a pane option at this exact pane target without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":128,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetOption","product":"core","slug":"tmux-pane-setoption"},{"id":"tmux.Server.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a server-scope option without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":144,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.AppendOption","product":"core","slug":"tmux-server-appendoption"},{"id":"tmux.GlobalSessionScope.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a global session option without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":165,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.AppendOption","product":"core","slug":"tmux-globalsessionscope-appendoption"},{"id":"tmux.GlobalWindowScope.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a global window option without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":186,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.AppendOption","product":"core","slug":"tmux-globalwindowscope-appendoption"},{"id":"tmux.Session.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a session option at this stable session target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":207,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.AppendOption","product":"core","slug":"tmux-session-appendoption"},{"id":"tmux.Window.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a window option at this exact window target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":223,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.AppendOption","product":"core","slug":"tmux-window-appendoption"},{"id":"tmux.Pane.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a pane option at this exact pane target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":243,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.AppendOption","product":"core","slug":"tmux-pane-appendoption"},{"id":"tmux.Server.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a server-scope option without refreshing existing models. UnsetPanes is invalid at server scope. Completed failures are secret-safe option errors; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":259,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.UnsetOption","product":"core","slug":"tmux-server-unsetoption"},{"id":"tmux.GlobalSessionScope.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a global session option without refreshing models. UnsetPanes is invalid at this scope; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":273,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.UnsetOption","product":"core","slug":"tmux-globalsessionscope-unsetoption"},{"id":"tmux.GlobalWindowScope.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a global window option without refreshing models. UnsetPanes is invalid at this scope; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":295,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.UnsetOption","product":"core","slug":"tmux-globalwindowscope-unsetoption"},{"id":"tmux.Session.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a session option at this stable session target without refreshing models. UnsetPanes is invalid at this scope; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":317,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.UnsetOption","product":"core","slug":"tmux-session-unsetoption"},{"id":"tmux.Window.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a window option at this exact window target, or its pane copies with UnsetPanes, without refreshing models. Cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":335,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.UnsetOption","product":"core","slug":"tmux-window-unsetoption"},{"id":"tmux.Pane.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a pane option at this exact pane target without refreshing models. UnsetPanes is invalid at this scope; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":358,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.UnsetOption","product":"core","slug":"tmux-pane-unsetoption"},{"id":"tmux.Server.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ServerOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known server options, including inherited values. A read or transport failure is returned rather than answered with zero values; context errors propagate. Each returned accessor names the setter that writes it, so [ServerOptionValues.BufferLimit] pairs with [Server.SetBufferLimit]."},"source":{"file":"tmux/option_read.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Options","product":"core","slug":"tmux-server-options"},{"id":"tmux.GlobalSessionScope.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(SessionOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known global session options, including defaults. A read failure is returned rather than answered with zero values; context errors propagate. Each returned accessor names the setter that writes it, so [SessionOptionValues.Status] pairs with [GlobalSessionScope.SetStatus]."},"source":{"file":"tmux/option_read.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.Options","product":"core","slug":"tmux-globalsessionscope-options"},{"id":"tmux.GlobalWindowScope.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(WindowOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known global window options, including defaults. A read failure is returned rather than answered with zero values; context errors propagate. Each returned accessor names the setter that writes it, so [WindowOptionValues.MainPaneWidth] pairs with [GlobalWindowScope.SetMainPaneWidth]."},"source":{"file":"tmux/option_read.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.Options","product":"core","slug":"tmux-globalwindowscope-options"},{"id":"tmux.Session.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(SessionOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known options at this stable session target, including inherited values. A read failure is returned rather than answered with zero values; context errors propagate. Each returned accessor names the setter that writes it, so [SessionOptionValues.Mouse] pairs with [Session.SetMouse]."},"source":{"file":"tmux/option_read.go","line":75,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Options","product":"core","slug":"tmux-session-options"},{"id":"tmux.Window.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(WindowOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known options at this exact window target, including inherited values. The receiver's exact linked session context controls tmux format evaluation. A read failure is returned rather than answered with zero values. Each returned accessor names the setter that writes it, so [WindowOptionValues.MainPaneWidth] pairs with [Window.SetMainPaneWidth]."},"source":{"file":"tmux/option_read.go","line":100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Options","product":"core","slug":"tmux-window-options"},{"id":"tmux.Pane.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(PaneOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known options at this exact pane target, including inherited values. The receiver's exact linked session context controls tmux format evaluation. A read failure is returned rather than answered with zero values. Each returned accessor names the setter that writes it, so [PaneOptionValues.WindowStyle] pairs with [Pane.SetWindowStyle]."},"source":{"file":"tmux/option_read.go","line":125,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Options","product":"core","slug":"tmux-pane-options"},{"id":"tmux.Server.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact server-scope option value. A successful string is caller-owned; ok reports presence. Targeted reads do not use list leniency, and completed failures return a secret-safe option error. An unindexed empty array is indistinguishable from an empty scalar; use Options for typed array presence."},"source":{"file":"tmux/option_read.go","line":149,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.RawOption","product":"core","slug":"tmux-server-rawoption"},{"id":"tmux.GlobalSessionScope.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact global session-option value. A successful string is caller-owned, and ok reports presence. An unindexed empty array is indistinguishable from an empty scalar; use Options for typed array presence."},"source":{"file":"tmux/option_read.go","line":157,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope.RawOption","product":"core","slug":"tmux-globalsessionscope-rawoption"},{"id":"tmux.GlobalWindowScope.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact global window-option value. A successful string is caller-owned, and ok reports presence. An unindexed empty array is indistinguishable from an empty scalar; use Options for typed array presence."},"source":{"file":"tmux/option_read.go","line":168,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope.RawOption","product":"core","slug":"tmux-globalwindowscope-rawoption"},{"id":"tmux.Session.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact session option value at this stable session target. A successful string is caller-owned; ok reports presence, and a completed failure is returned rather than normalized. An unindexed empty array is indistinguishable from an empty scalar; use Options for typed array presence."},"source":{"file":"tmux/option_read.go","line":180,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.RawOption","product":"core","slug":"tmux-session-rawoption"},{"id":"tmux.Window.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact window option value at this exact window target. A successful string is caller-owned; the receiver's exact linked session context controls tmux format evaluation, and a completed failure is returned."},"source":{"file":"tmux/option_read.go","line":191,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.RawOption","product":"core","slug":"tmux-window-rawoption"},{"id":"tmux.Pane.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact pane option value at this exact pane target. A successful string is caller-owned; the receiver's exact linked session context controls tmux format evaluation, and a completed failure is returned."},"source":{"file":"tmux/option_read.go","line":202,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.RawOption","product":"core","slug":"tmux-pane-rawoption"},{"id":"tmux.SetArrayResult","name":"SetArrayResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetArrayResult reports confirmed progress from a typed sparse-array replacement. AppliedIndices is caller-owned and is non-nil whenever mutation was attempted."},"source":{"file":"tmux/option_runtime.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetArrayResult","product":"core","slug":"tmux-setarrayresult"},{"id":"tmux.SetArrayResult.Replaced","name":"Replaced","kind":"attribute","modifiers":[],"parent":"tmux.SetArrayResult","signatures":[],"type":"bool","doc":{"summary":"Replaced reports whether tmux confirmed the base replacement."},"source":{"file":"tmux/option_runtime.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetArrayResult.Replaced","product":"core","slug":"tmux-setarrayresult-replaced"},{"id":"tmux.SetArrayResult.AppliedIndices","name":"AppliedIndices","kind":"attribute","modifiers":[],"parent":"tmux.SetArrayResult","signatures":[],"type":"[]int","doc":{"summary":"AppliedIndices lists confirmed indexed writes in ascending order."},"source":{"file":"tmux/option_runtime.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetArrayResult.AppliedIndices","product":"core","slug":"tmux-setarrayresult-appliedindices"},{"id":"tmux.GlobalSessionScope","name":"GlobalSessionScope","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"GlobalSessionScope is an immutable handle for global session options and hooks. Its zero value is invalid because it contains a zero [Server]."},"source":{"file":"tmux/option_scope.go","line":5,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalSessionScope","product":"core","slug":"tmux-globalsessionscope"},{"id":"tmux.GlobalWindowScope","name":"GlobalWindowScope","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"GlobalWindowScope is an immutable handle for global window options and hooks. Its zero value is invalid because it contains a zero [Server]."},"source":{"file":"tmux/option_scope.go","line":11,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.GlobalWindowScope","product":"core","slug":"tmux-globalwindowscope"},{"id":"tmux.Server.GlobalSessionScope","name":"GlobalSessionScope","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"GlobalSessionScope"}],"doc":{"summary":"GlobalSessionScope returns a handle that preserves s and its error policy."},"source":{"file":"tmux/option_scope.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.GlobalSessionScope","product":"core","slug":"tmux-server-globalsessionscope"},{"id":"tmux.Server.GlobalWindowScope","name":"GlobalWindowScope","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"GlobalWindowScope"}],"doc":{"summary":"GlobalWindowScope returns a handle that preserves s and its error policy."},"source":{"file":"tmux/option_scope.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.GlobalWindowScope","product":"core","slug":"tmux-server-globalwindowscope"},{"id":"tmux.OptionOrigin","name":"OptionOrigin","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionOrigin identifies where a present option value was resolved. The declared values form the complete set of valid origins."},"source":{"file":"tmux/option_value.go","line":7,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionOrigin","product":"core","slug":"tmux-optionorigin"},{"id":"tmux.OptionOrigin.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.OptionOrigin","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the origin's tmux vocabulary, so an origin prints as a word beside the generated option values, which all carry String."},"source":{"file":"tmux/option_value.go","line":11,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionOrigin.String","product":"core","slug":"tmux-optionorigin-string"},{"id":"tmux.OptionOriginLocal","name":"OptionOriginLocal","kind":"constant","modifiers":[],"signatures":[],"type":"OptionOrigin","doc":{"summary":"OptionOriginLocal identifies a value set directly at the queried scope."},"source":{"file":"tmux/option_value.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionOriginLocal","product":"core","slug":"tmux-optionoriginlocal"},{"id":"tmux.OptionOriginInherited","name":"OptionOriginInherited","kind":"constant","modifiers":[],"signatures":[],"type":"OptionOrigin","doc":{"summary":"OptionOriginInherited identifies a value inherited from a parent scope."},"source":{"file":"tmux/option_value.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionOriginInherited","product":"core","slug":"tmux-optionorigininherited"},{"id":"tmux.OptionValue","name":"OptionValue","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionValue preserves option presence and resolution origin. Its zero value is absent. Copies of reference-bearing T values are shallow."},"source":{"file":"tmux/option_value.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionValue","product":"core","slug":"tmux-optionvalue"},{"id":"tmux.OptionValue.Get","name":"Get","kind":"method","modifiers":[],"parent":"tmux.OptionValue","signatures":[{"params":[],"returns":"(T, bool)"}],"doc":{"summary":"Get returns the option value and reports whether it is present."},"source":{"file":"tmux/option_value.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionValue.Get","product":"core","slug":"tmux-optionvalue-get"},{"id":"tmux.OptionValue.Origin","name":"Origin","kind":"method","modifiers":[],"parent":"tmux.OptionValue","signatures":[{"params":[],"returns":"(OptionOrigin, bool)"}],"doc":{"summary":"Origin returns the resolution origin and reports whether the option is present."},"source":{"file":"tmux/option_value.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OptionValue.Origin","product":"core","slug":"tmux-optionvalue-origin"},{"id":"tmux.ErrInvalidCaptureRequest","name":"ErrInvalidCaptureRequest","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidCaptureRequest identifies a capture request that cannot be represented safely as tmux arguments."},"source":{"file":"tmux/pane_capture.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidCaptureRequest","product":"core","slug":"tmux-errinvalidcapturerequest"},{"id":"tmux.CaptureRequestError","name":"CaptureRequestError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CaptureRequestError reports a [CapturePaneRequest] field that cannot be represented as a tmux capture-pane argument. It matches [ErrInvalidCaptureRequest] through [errors.Is] and is available through [errors.As]."},"source":{"file":"tmux/pane_capture.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CaptureRequestError","product":"core","slug":"tmux-capturerequesterror"},{"id":"tmux.CaptureRequestError.Field","name":"Field","kind":"attribute","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[],"type":"string","doc":{"summary":"Field names the invalid request field."},"source":{"file":"tmux/pane_capture.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CaptureRequestError.Field","product":"core","slug":"tmux-capturerequesterror-field"},{"id":"tmux.CaptureRequestError.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[],"type":"string","doc":{"summary":"Value is the rejected field value. It may be empty when absence is the error."},"source":{"file":"tmux/pane_capture.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CaptureRequestError.Value","product":"core","slug":"tmux-capturerequesterror-value"},{"id":"tmux.CaptureRequestError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[],"type":"string","doc":{"summary":"Reason describes the violated request constraint without promising a stable complete error string."},"source":{"file":"tmux/pane_capture.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CaptureRequestError.Reason","product":"core","slug":"tmux-capturerequesterror-reason"},{"id":"tmux.CaptureRequestError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/pane_capture.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CaptureRequestError.Error","product":"core","slug":"tmux-capturerequesterror-error"},{"id":"tmux.CaptureRequestError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes CaptureRequestError compatible with ErrInvalidCaptureRequest."},"source":{"file":"tmux/pane_capture.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CaptureRequestError.Unwrap","product":"core","slug":"tmux-capturerequesterror-unwrap"},{"id":"tmux.CapturePosition","name":"CapturePosition","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CapturePosition selects a line relative to tmux's visible pane or history. Its zero value omits the boundary and lets tmux use the visible-screen default. Construct numeric positions with [CaptureLine]."},"source":{"file":"tmux/pane_capture.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePosition","product":"core","slug":"tmux-captureposition"},{"id":"tmux.CaptureBoundary","name":"CaptureBoundary","kind":"constant","modifiers":[],"signatures":[],"type":"CapturePosition","doc":{"summary":"CaptureBoundary selects the start of history when used as Start and the end of the visible pane when used as End."},"source":{"file":"tmux/pane_capture.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CaptureBoundary","product":"core","slug":"tmux-captureboundary"},{"id":"tmux.CaptureLine","name":"CaptureLine","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"line","type":"int"}],"returns":"CapturePosition"}],"doc":{"summary":"CaptureLine returns the canonical tmux representation of a capture line. Zero is the first visible line; negative values address history."},"source":{"file":"tmux/pane_capture.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CaptureLine","product":"core","slug":"tmux-captureline"},{"id":"tmux.CapturePaneRequest","name":"CapturePaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CapturePaneRequest configures pane capture. Its zero value captures the visible screen with tmux's default text handling. Version-gated flags follow [UnsupportedPolicy]. [CaptureBoundary] selects the start of history for Start and the end of the visible pane for End."},"source":{"file":"tmux/pane_capture.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest","product":"core","slug":"tmux-capturepanerequest"},{"id":"tmux.CapturePaneRequest.Start","name":"Start","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"CapturePosition","doc":{"summary":"Start selects the first captured line. Empty uses tmux's visible-screen default; CaptureBoundary selects the start of history."},"source":{"file":"tmux/pane_capture.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.Start","product":"core","slug":"tmux-capturepanerequest-start"},{"id":"tmux.CapturePaneRequest.End","name":"End","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"CapturePosition","doc":{"summary":"End selects the last captured line. Empty uses tmux's visible-screen default; CaptureBoundary selects the end of the visible pane."},"source":{"file":"tmux/pane_capture.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.End","product":"core","slug":"tmux-capturepanerequest-end"},{"id":"tmux.CapturePaneRequest.EscapeSequences","name":"EscapeSequences","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"EscapeSequences includes terminal attribute escape sequences."},"source":{"file":"tmux/pane_capture.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.EscapeSequences","product":"core","slug":"tmux-capturepanerequest-escapesequences"},{"id":"tmux.CapturePaneRequest.EscapeNonPrintable","name":"EscapeNonPrintable","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"EscapeNonPrintable renders non-printable characters as octal escapes."},"source":{"file":"tmux/pane_capture.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.EscapeNonPrintable","product":"core","slug":"tmux-capturepanerequest-escapenonprintable"},{"id":"tmux.CapturePaneRequest.JoinWrapped","name":"JoinWrapped","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"JoinWrapped joins wrapped lines, preserves their trailing spaces, and implies tmux trimming independently of TrimTrailing."},"source":{"file":"tmux/pane_capture.go","line":85,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.JoinWrapped","product":"core","slug":"tmux-capturepanerequest-joinwrapped"},{"id":"tmux.CapturePaneRequest.PreserveTrailing","name":"PreserveTrailing","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"PreserveTrailing preserves trailing spaces at each line end."},"source":{"file":"tmux/pane_capture.go","line":87,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.PreserveTrailing","product":"core","slug":"tmux-capturepanerequest-preservetrailing"},{"id":"tmux.CapturePaneRequest.TrimTrailing","name":"TrimTrailing","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"TrimTrailing omits trailing positions without characters. It requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.TrimTrailing","product":"core","slug":"tmux-capturepanerequest-trimtrailing"},{"id":"tmux.CapturePaneRequest.AlternateScreen","name":"AlternateScreen","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"AlternateScreen captures the alternate screen without history."},"source":{"file":"tmux/pane_capture.go","line":92,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.AlternateScreen","product":"core","slug":"tmux-capturepanerequest-alternatescreen"},{"id":"tmux.CapturePaneRequest.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux's error when AlternateScreen is requested but no alternate screen exists."},"source":{"file":"tmux/pane_capture.go","line":95,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.Quiet","product":"core","slug":"tmux-capturepanerequest-quiet"},{"id":"tmux.CapturePaneRequest.ModeScreen","name":"ModeScreen","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"ModeScreen captures the active mode screen. It requires tmux 3.6; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":98,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.ModeScreen","product":"core","slug":"tmux-capturepanerequest-modescreen"},{"id":"tmux.CapturePaneRequest.Pending","name":"Pending","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Pending captures only the beginning of an incomplete escape sequence."},"source":{"file":"tmux/pane_capture.go","line":100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.Pending","product":"core","slug":"tmux-capturepanerequest-pending"},{"id":"tmux.CapturePaneRequest.Hyperlinks","name":"Hyperlinks","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Hyperlinks captures hyperlink metadata for the selected lines. It requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.Hyperlinks","product":"core","slug":"tmux-capturepanerequest-hyperlinks"},{"id":"tmux.CapturePaneRequest.LineNumbers","name":"LineNumbers","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"LineNumbers prefixes each line with its tmux line number. It requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.LineNumbers","product":"core","slug":"tmux-capturepanerequest-linenumbers"},{"id":"tmux.CapturePaneRequest.LineFlags","name":"LineFlags","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"LineFlags prefixes each line with tmux line metadata flags. It requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":109,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CapturePaneRequest.LineFlags","product":"core","slug":"tmux-capturepanerequest-lineflags"},{"id":"tmux.Pane.Capture","name":"Capture","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"CapturePaneRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"Capture captures printed content from the receiver's exact linked pane. It returns a caller-owned slice. A completed nonzero exit or stderr becomes a [CommandError]; any stdout tmux still printed is returned alongside it.","body":"This is a point-in-time capture rather than a stream; the zero request reads\nthe visible screen. It may include a shell's echo of [Pane.SendKeys] input.\nCompare whole lines when polling; use [ControlClient.NextNotification] or\n[Server.WaitFor] when the application exposes a stream or explicit signal.\n\nInvalid positions fail before execution. Transport and context failures return\nany partial stdout with the error."},"source":{"file":"tmux/pane_capture.go","line":123,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Capture","product":"core","slug":"tmux-pane-capture"},{"id":"tmux.Pane.CaptureBytes","name":"CaptureBytes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"CapturePaneRequest"}],"returns":"([]byte, error)"}],"doc":{"summary":"CaptureBytes captures printed content from the receiver's exact linked pane as caller-owned stdout bytes. It preserves tmux's output delimiters and trailing newlines after tmux has interpreted the pane's terminal contents.","body":"Its validation and failure behavior match [Pane.Capture], including returning\npartial bytes with transport or context errors."},"source":{"file":"tmux/pane_capture.go","line":137,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CaptureBytes","product":"core","slug":"tmux-pane-capturebytes"},{"id":"tmux.Pane.CaptureToBuffer","name":"CaptureToBuffer","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"buffer","type":"string"},{"name":"request","type":"CapturePaneRequest"}],"returns":"error"}],"doc":{"summary":"CaptureToBuffer captures content from the receiver's exact linked pane into the nonempty named tmux buffer. The buffer is owned by tmux and no printed output is returned. A completed nonzero exit or stderr becomes a [CommandError].","body":"Invalid requests fail before execution. Transport and context errors are\ndelivery-ambiguous: the buffer may already have changed."},"source":{"file":"tmux/pane_capture.go","line":152,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CaptureToBuffer","product":"core","slug":"tmux-pane-capturetobuffer"},{"id":"tmux.Pane.CaptureToFile","name":"CaptureToFile","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"path","type":"string"},{"name":"request","type":"CapturePaneRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"CaptureToFile captures the receiver's exact linked pane through a tmux buffer and the file at path, returning the same lines [Pane.Capture] returns.","body":"Printed captures cannot safely cross a control connection, so [Pane.Capture]\nand [Pane.CaptureBytes] use a subprocess or reject a connection. CaptureToFile\nstages through a scratch buffer so capture, save, and cleanup can all use the\nconnection's command lanes.\n\npath must name a file the tmux server can write and this process can read.\nIt is replaced and left for the caller. Concurrent calls must use distinct\npaths. The scratch tmux buffer is deleted before return when possible.\n\nValidation and version gating match [Pane.Capture]. Capture, save, and\nfile-read failures return an error with no lines; buffer cleanup is best effort."},"source":{"file":"tmux/pane_capture.go","line":180,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CaptureToFile","product":"core","slug":"tmux-pane-capturetofile"},{"id":"tmux.Pane.CaptureTo","name":"CaptureTo","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"destination","type":"io.Writer"},{"name":"request","type":"CapturePaneRequest"}],"returns":"error"}],"doc":{"summary":"CaptureTo streams printed content from the receiver's exact linked pane into destination without holding a screen in memory, which is what makes a long scrollback affordable to write straight to a file or a compressor. Like [Pane.Capture] it reads the screen at one point in time rather than following it; the zero request reads the visible screen and version-gated fields follow [UnsupportedPolicy].","body":"A completed nonzero exit becomes a redacted command error, because CaptureTo\nreturns no bytes for the caller to inspect. Cancellation does not prove\ndestination received the complete screen, and a copy failure takes\nprecedence over a completed command's exit status because it means\ndestination never saw everything tmux sent. Printed captures always use a\nsubprocess, so a [Connection]-bound Pane returns\n[ErrConnectionRequiresProcess]; [Pane.CaptureToFile] stages through a tmux\nbuffer and runs over a connection."},"source":{"file":"tmux/pane_capture.go","line":388,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CaptureTo","product":"core","slug":"tmux-pane-captureto"},{"id":"tmux.NewPaneRequest","name":"NewPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NewPaneRequest configures a floating pane and requires tmux 3.7 or later. Its zero value creates a detached floating pane with tmux's default size, position, styles, and command. Nil pointer fields omit their options; nonnil pointers are explicit, including empty style or message strings. Width and Height must be nonnegative. Empty and Command are mutually exclusive. Unsupported tmux versions return [VersionTooLowError] rather than omitting fields.","body":"Methods copy pointers and Environment before I/O; concurrent mutation during\nthe copy is unsafe."},"source":{"file":"tmux/pane_create.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest","product":"core","slug":"tmux-newpanerequest"},{"id":"tmux.NewPaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets the created pane become active in the exact target winlink; false preserves its active pane."},"source":{"file":"tmux/pane_create.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Attach","product":"core","slug":"tmux-newpanerequest-attach"},{"id":"tmux.NewPaneRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Named-user forms such as ~other are rejected; empty inherits tmux's default."},"source":{"file":"tmux/pane_create.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.StartDirectory","product":"core","slug":"tmux-newpanerequest-startdirectory"},{"id":"tmux.NewPaneRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"string","doc":{"summary":"Command starts the pane with this shell command; empty uses tmux's default."},"source":{"file":"tmux/pane_create.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Command","product":"core","slug":"tmux-newpanerequest-command"},{"id":"tmux.NewPaneRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order. The map is not retained; nil and an empty map both add no entries."},"source":{"file":"tmux/pane_create.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Environment","product":"core","slug":"tmux-newpanerequest-environment"},{"id":"tmux.NewPaneRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Width sets a nonnegative pane width; nil lets tmux choose."},"source":{"file":"tmux/pane_create.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Width","product":"core","slug":"tmux-newpanerequest-width"},{"id":"tmux.NewPaneRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Height sets a nonnegative pane height; nil lets tmux choose."},"source":{"file":"tmux/pane_create.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Height","product":"core","slug":"tmux-newpanerequest-height"},{"id":"tmux.NewPaneRequest.X","name":"X","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*int","doc":{"summary":"X sets the horizontal position; nil lets tmux choose."},"source":{"file":"tmux/pane_create.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.X","product":"core","slug":"tmux-newpanerequest-x"},{"id":"tmux.NewPaneRequest.Y","name":"Y","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Y sets the vertical position; nil lets tmux choose."},"source":{"file":"tmux/pane_create.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Y","product":"core","slug":"tmux-newpanerequest-y"},{"id":"tmux.NewPaneRequest.Zoom","name":"Zoom","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Zoom preserves the target window's zoomed state."},"source":{"file":"tmux/pane_create.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Zoom","product":"core","slug":"tmux-newpanerequest-zoom"},{"id":"tmux.NewPaneRequest.Empty","name":"Empty","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Empty creates a pane without starting a command."},"source":{"file":"tmux/pane_create.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Empty","product":"core","slug":"tmux-newpanerequest-empty"},{"id":"tmux.NewPaneRequest.Style","name":"Style","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*string","doc":{"summary":"Style sets the pane style; nil omits it."},"source":{"file":"tmux/pane_create.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Style","product":"core","slug":"tmux-newpanerequest-style"},{"id":"tmux.NewPaneRequest.ActiveBorderStyle","name":"ActiveBorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*string","doc":{"summary":"ActiveBorderStyle sets the active border style; nil omits it."},"source":{"file":"tmux/pane_create.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.ActiveBorderStyle","product":"core","slug":"tmux-newpanerequest-activeborderstyle"},{"id":"tmux.NewPaneRequest.InactiveBorderStyle","name":"InactiveBorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*string","doc":{"summary":"InactiveBorderStyle sets the inactive border style; nil omits it."},"source":{"file":"tmux/pane_create.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.InactiveBorderStyle","product":"core","slug":"tmux-newpanerequest-inactiveborderstyle"},{"id":"tmux.NewPaneRequest.Message","name":"Message","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*string","doc":{"summary":"Message sets the pane message; nil omits it."},"source":{"file":"tmux/pane_create.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Message","product":"core","slug":"tmux-newpanerequest-message"},{"id":"tmux.NewPaneRequest.Keep","name":"Keep","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Keep preserves the pane after its command exits."},"source":{"file":"tmux/pane_create.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPaneRequest.Keep","product":"core","slug":"tmux-newpanerequest-keep"},{"id":"tmux.SplitPaneRequest","name":"SplitPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SplitPaneRequest configures tiled pane creation on tmux 3.2a or later. Its zero value creates a detached pane below the exact target with tmux's default size and command. Nil pointer fields omit their options; nonnil pointers are explicit, including empty style or message strings. Size and Percentage are mutually exclusive. Invalid values are rejected before tmux is mutated.","body":"Methods copy pointer and map values before I/O; concurrent mutation is unsafe.\nEmpty, styles, Message, and Keep require tmux 3.7 and follow\n[UnsupportedPolicy]. Empty and Command conflict only when Empty is supported."},"source":{"file":"tmux/pane_create.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest","product":"core","slug":"tmux-splitpanerequest"},{"id":"tmux.SplitPaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets the created pane become active in the exact target winlink; false preserves its active pane."},"source":{"file":"tmux/pane_create.go","line":70,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Attach","product":"core","slug":"tmux-splitpanerequest-attach"},{"id":"tmux.SplitPaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"PaneDirection","doc":{"summary":"Direction selects the side of the target; zero means below."},"source":{"file":"tmux/pane_create.go","line":72,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Direction","product":"core","slug":"tmux-splitpanerequest-direction"},{"id":"tmux.SplitPaneRequest.Size","name":"Size","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Size selects a nonnegative absolute pane size; nil omits it."},"source":{"file":"tmux/pane_create.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Size","product":"core","slug":"tmux-splitpanerequest-size"},{"id":"tmux.SplitPaneRequest.Percentage","name":"Percentage","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Percentage selects a size from 0 through 100; nil omits it. It is sent as tmux's \"-l N%\", which every supported version accepts; the older -p spelling is rejected by tmux 3.4."},"source":{"file":"tmux/pane_create.go","line":78,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Percentage","product":"core","slug":"tmux-splitpanerequest-percentage"},{"id":"tmux.SplitPaneRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Named-user forms such as ~other are rejected; empty inherits tmux's default."},"source":{"file":"tmux/pane_create.go","line":81,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.StartDirectory","product":"core","slug":"tmux-splitpanerequest-startdirectory"},{"id":"tmux.SplitPaneRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"string","doc":{"summary":"Command starts the pane with this shell command; empty uses tmux's default."},"source":{"file":"tmux/pane_create.go","line":83,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Command","product":"core","slug":"tmux-splitpanerequest-command"},{"id":"tmux.SplitPaneRequest.FullWindow","name":"FullWindow","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"FullWindow lets the new pane span the full window size."},"source":{"file":"tmux/pane_create.go","line":85,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.FullWindow","product":"core","slug":"tmux-splitpanerequest-fullwindow"},{"id":"tmux.SplitPaneRequest.Zoom","name":"Zoom","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Zoom preserves the window's zoomed state after the split."},"source":{"file":"tmux/pane_create.go","line":87,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Zoom","product":"core","slug":"tmux-splitpanerequest-zoom"},{"id":"tmux.SplitPaneRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order and is not retained; nil and an empty map both add no entries."},"source":{"file":"tmux/pane_create.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Environment","product":"core","slug":"tmux-splitpanerequest-environment"},{"id":"tmux.SplitPaneRequest.Empty","name":"Empty","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Empty requests an empty pane on tmux 3.7 or later."},"source":{"file":"tmux/pane_create.go","line":92,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Empty","product":"core","slug":"tmux-splitpanerequest-empty"},{"id":"tmux.SplitPaneRequest.Style","name":"Style","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*string","doc":{"summary":"Style sets the pane style on tmux 3.7 or later; nil omits it."},"source":{"file":"tmux/pane_create.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Style","product":"core","slug":"tmux-splitpanerequest-style"},{"id":"tmux.SplitPaneRequest.ActiveBorderStyle","name":"ActiveBorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*string","doc":{"summary":"ActiveBorderStyle sets the active border style on tmux 3.7 or later; nil omits it."},"source":{"file":"tmux/pane_create.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.ActiveBorderStyle","product":"core","slug":"tmux-splitpanerequest-activeborderstyle"},{"id":"tmux.SplitPaneRequest.InactiveBorderStyle","name":"InactiveBorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*string","doc":{"summary":"InactiveBorderStyle sets the inactive border style on tmux 3.7 or later; nil omits it."},"source":{"file":"tmux/pane_create.go","line":100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.InactiveBorderStyle","product":"core","slug":"tmux-splitpanerequest-inactiveborderstyle"},{"id":"tmux.SplitPaneRequest.Message","name":"Message","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*string","doc":{"summary":"Message sets the pane message on tmux 3.7 or later; nil omits it."},"source":{"file":"tmux/pane_create.go","line":102,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Message","product":"core","slug":"tmux-splitpanerequest-message"},{"id":"tmux.SplitPaneRequest.Keep","name":"Keep","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Keep preserves the pane after its command exits on tmux 3.7 or later."},"source":{"file":"tmux/pane_create.go","line":104,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SplitPaneRequest.Keep","product":"core","slug":"tmux-splitpanerequest-keep"},{"id":"tmux.Window.NewPane","name":"NewPane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"NewPane creates a floating pane in the receiver's exact winlink. Attach makes the new pane active in that session and winlink; it is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the receiver SessionID and WindowID rather than by canonical ID-only refresh.","body":"If tmux reports a [PaneID] before a transport or refresh failure, the partial\nresult includes the receiver SessionID and WindowID. Other failures return\nzero; creation is not rolled back."},"source":{"file":"tmux/pane_create.go","line":115,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.NewPane","product":"core","slug":"tmux-window-newpane"},{"id":"tmux.Pane.NewPane","name":"NewPane","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"NewPane creates a floating pane relative to the receiver's exact linked-pane view. Attach makes the new pane active in that session and winlink; it is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the receiver SessionID and WindowID.","body":"If tmux reports a [PaneID] before a transport or refresh failure, the partial\nresult includes the receiver SessionID and WindowID. Other failures return\nzero; creation is not rolled back."},"source":{"file":"tmux/pane_create.go","line":132,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.NewPane","product":"core","slug":"tmux-pane-newpane"},{"id":"tmux.Window.SplitPane","name":"SplitPane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SplitPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"SplitPane creates a tiled pane in the receiver's exact winlink. Attach makes the new pane active in that session and winlink; it is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the receiver SessionID and WindowID rather than by canonical ID-only refresh. [Pane.Split] is the equivalent operation relative to an existing pane rather than its window.","body":"If tmux reports a [PaneID] before a transport or refresh failure, the partial\nresult also contains the receiver SessionID and WindowID. Other failures\nreturn zero; creation is not rolled back."},"source":{"file":"tmux/pane_create.go","line":302,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SplitPane","product":"core","slug":"tmux-window-splitpane"},{"id":"tmux.Pane.Split","name":"Split","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SplitPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Split creates a tiled pane relative to the receiver's exact linked-pane view. Attach makes the new pane active in that session and winlink; it is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the receiver SessionID and WindowID. Named Split rather than SplitPane to avoid repeating Pane; [Window.SplitPane] is the equivalent operation relative to a window.","body":"If tmux reports a [PaneID] before a transport or refresh failure, the partial\nresult also contains the receiver SessionID and WindowID. Other failures\nreturn zero; creation is not rolled back."},"source":{"file":"tmux/pane_create.go","line":321,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Split","product":"core","slug":"tmux-pane-split"},{"id":"tmux.PaneResizeDirection","name":"PaneResizeDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneResizeDirection selects a directional [Pane.Resize]. Its zero value selects no directional adjustment."},"source":{"file":"tmux/pane_geometry.go","line":10,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneResizeDirection","product":"core","slug":"tmux-paneresizedirection"},{"id":"tmux.PaneResizeDirectionNone","name":"PaneResizeDirectionNone","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionNone omits a directional resize."},"source":{"file":"tmux/pane_geometry.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneResizeDirectionNone","product":"core","slug":"tmux-paneresizedirectionnone"},{"id":"tmux.PaneResizeDirectionUp","name":"PaneResizeDirectionUp","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionUp selects tmux's upward adjustment."},"source":{"file":"tmux/pane_geometry.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneResizeDirectionUp","product":"core","slug":"tmux-paneresizedirectionup"},{"id":"tmux.PaneResizeDirectionDown","name":"PaneResizeDirectionDown","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionDown selects tmux's downward adjustment."},"source":{"file":"tmux/pane_geometry.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneResizeDirectionDown","product":"core","slug":"tmux-paneresizedirectiondown"},{"id":"tmux.PaneResizeDirectionLeft","name":"PaneResizeDirectionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionLeft selects tmux's leftward adjustment."},"source":{"file":"tmux/pane_geometry.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneResizeDirectionLeft","product":"core","slug":"tmux-paneresizedirectionleft"},{"id":"tmux.PaneResizeDirectionRight","name":"PaneResizeDirectionRight","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionRight selects tmux's rightward adjustment."},"source":{"file":"tmux/pane_geometry.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneResizeDirectionRight","product":"core","slug":"tmux-paneresizedirectionright"},{"id":"tmux.PaneSize","name":"PaneSize","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneSize is an opaque absolute cell count or percentage for [Pane.Resize]. Its zero value omits the dimension. [PaneCells](0) and [PanePercent](0) are explicit sizes, not zero PaneSize values."},"source":{"file":"tmux/pane_geometry.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSize","product":"core","slug":"tmux-panesize"},{"id":"tmux.PaneCells","name":"PaneCells","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"cells","type":"int"}],"returns":"PaneSize"}],"doc":{"summary":"PaneCells returns an explicit pane size measured in cells. Resize validates that cells is nonnegative; zero remains an explicit request."},"source":{"file":"tmux/pane_geometry.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneCells","product":"core","slug":"tmux-panecells"},{"id":"tmux.PanePercent","name":"PanePercent","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"percent","type":"int"}],"returns":"PaneSize"}],"doc":{"summary":"PanePercent returns an explicit percentage of the window size. Resize validates that percent is between 0 and 100 inclusive; zero remains an explicit request."},"source":{"file":"tmux/pane_geometry.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PanePercent","product":"core","slug":"tmux-panepercent"},{"id":"tmux.ResizePaneRequest","name":"ResizePaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ResizePaneRequest selects one resize mode. Direction with Adjustment, dimensions, Zoom, Mouse, and TrimBelow are mutually exclusive modes; Height and Width may be set together. Its zero value sends a bare tmux resize-pane command rather than selecting a mode. When Direction is [PaneResizeDirectionNone], Adjustment must be zero."},"source":{"file":"tmux/pane_geometry.go","line":59,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizePaneRequest","product":"core","slug":"tmux-resizepanerequest"},{"id":"tmux.ResizePaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"PaneResizeDirection","doc":{"summary":"Direction selects a directional resize and requires Adjustment."},"source":{"file":"tmux/pane_geometry.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizePaneRequest.Direction","product":"core","slug":"tmux-resizepanerequest-direction"},{"id":"tmux.ResizePaneRequest.Adjustment","name":"Adjustment","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"int","doc":{"summary":"Adjustment is the positive number of cells moved in Direction. It must be zero when Direction is PaneResizeDirectionNone."},"source":{"file":"tmux/pane_geometry.go","line":64,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizePaneRequest.Adjustment","product":"core","slug":"tmux-resizepanerequest-adjustment"},{"id":"tmux.ResizePaneRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"PaneSize","doc":{"summary":"Height sets an absolute or percentage height. A zero PaneSize omits it."},"source":{"file":"tmux/pane_geometry.go","line":66,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizePaneRequest.Height","product":"core","slug":"tmux-resizepanerequest-height"},{"id":"tmux.ResizePaneRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"PaneSize","doc":{"summary":"Width sets an absolute or percentage width. A zero PaneSize omits it."},"source":{"file":"tmux/pane_geometry.go","line":68,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizePaneRequest.Width","product":"core","slug":"tmux-resizepanerequest-width"},{"id":"tmux.ResizePaneRequest.Zoom","name":"Zoom","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Zoom toggles the pane between its normal layout and full-window zoom."},"source":{"file":"tmux/pane_geometry.go","line":70,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizePaneRequest.Zoom","product":"core","slug":"tmux-resizepanerequest-zoom"},{"id":"tmux.ResizePaneRequest.Mouse","name":"Mouse","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Mouse begins tmux mouse resizing and is meaningful from a mouse binding."},"source":{"file":"tmux/pane_geometry.go","line":72,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizePaneRequest.Mouse","product":"core","slug":"tmux-resizepanerequest-mouse"},{"id":"tmux.ResizePaneRequest.TrimBelow","name":"TrimBelow","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"bool","doc":{"summary":"TrimBelow removes lines below the cursor and refills from history."},"source":{"file":"tmux/pane_geometry.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizePaneRequest.TrimBelow","product":"core","slug":"tmux-resizepanerequest-trimbelow"},{"id":"tmux.Pane.Resize","name":"Resize","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ResizePaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Resize runs tmux resize-pane against the receiver's exact linked session-window-pane target, then refreshes by PaneID. The returned canonical [Pane] may therefore carry a different linked-session or winlink context. If the resize is accepted but refresh fails, Resize returns the original receiver with that error.","body":"Invalid requests fail before execution. A completed command produces a\nredacted [CommandError] only for stderr; nonzero exits without stderr are\nfollowed by refresh. Transport errors return zero and are delivery-ambiguous."},"source":{"file":"tmux/pane_geometry.go","line":86,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Resize","product":"core","slug":"tmux-pane-resize"},{"id":"tmux.Pane.SetWidth","name":"SetWidth","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"width","type":"int"}],"returns":"(Pane, error)"}],"doc":{"summary":"SetWidth resizes the pane to a nonnegative absolute width in cells. Zero is an explicit width. Targeting, refresh, and error semantics match [Pane.Resize]."},"source":{"file":"tmux/pane_geometry.go","line":153,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetWidth","product":"core","slug":"tmux-pane-setwidth"},{"id":"tmux.Pane.SetHeight","name":"SetHeight","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"height","type":"int"}],"returns":"(Pane, error)"}],"doc":{"summary":"SetHeight resizes the pane to a nonnegative absolute height in cells. Zero is an explicit height. Targeting, refresh, and error semantics match [Pane.Resize]."},"source":{"file":"tmux/pane_geometry.go","line":160,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetHeight","product":"core","slug":"tmux-pane-setheight"},{"id":"tmux.Pane.SetTitle","name":"SetTitle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"title","type":"string"}],"returns":"(Pane, error)"}],"doc":{"summary":"SetTitle sets the title of the receiver's exact linked pane. tmux expands format expressions in title; the value is not a shell command. SetTitle then refreshes by PaneID, so the returned canonical [Pane] may carry a different linked-session or winlink context. If the mutation is accepted but refresh fails, SetTitle returns the original receiver with that error.","body":"Completed stderr produces a redacted [CommandError]; nonzero exits without\nstderr are followed by refresh. Transport errors return zero and are\ndelivery-ambiguous."},"source":{"file":"tmux/pane_geometry.go","line":173,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SetTitle","product":"core","slug":"tmux-pane-settitle"},{"id":"tmux.SendKeysRequest","name":"SendKeysRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SendKeysRequest configures tmux key input. Pointer values are copied before I/O and must not be mutated concurrently.","body":"Command must be nonnil unless Reset, Repeat, or CopyModeCommand is set. A\nnonnil empty Command is an explicit key operand and is followed by Enter\nunless SkipEnter is set. CopyModeCommand takes precedence over Command and\nsuppresses Enter. HexKeys takes precedence over Literal when both are set."},"source":{"file":"tmux/pane_input.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest","product":"core","slug":"tmux-sendkeysrequest"},{"id":"tmux.SendKeysRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"*string","doc":{"summary":"Command is one tmux key operand. Nil selects a flag-only invocation; nonnil, including an empty string, supplies the operand."},"source":{"file":"tmux/pane_input.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.Command","product":"core","slug":"tmux-sendkeysrequest-command"},{"id":"tmux.SendKeysRequest.SkipEnter","name":"SkipEnter","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"SkipEnter prevents the separate Enter key sent after Command."},"source":{"file":"tmux/pane_input.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.SkipEnter","product":"core","slug":"tmux-sendkeysrequest-skipenter"},{"id":"tmux.SendKeysRequest.SuppressHistory","name":"SuppressHistory","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"SuppressHistory prefixes Command with one space. Whether that excludes the text from history depends on the application or shell in the pane."},"source":{"file":"tmux/pane_input.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.SuppressHistory","product":"core","slug":"tmux-sendkeysrequest-suppresshistory"},{"id":"tmux.SendKeysRequest.Literal","name":"Literal","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"Literal disables tmux key-name lookup and treats Command as literal UTF-8. It does not bypass interpretation by the pane's application or shell."},"source":{"file":"tmux/pane_input.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.Literal","product":"core","slug":"tmux-sendkeysrequest-literal"},{"id":"tmux.SendKeysRequest.Reset","name":"Reset","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"Reset asks tmux to reset terminal state before processing key input."},"source":{"file":"tmux/pane_input.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.Reset","product":"core","slug":"tmux-sendkeysrequest-reset"},{"id":"tmux.SendKeysRequest.CopyModeCommand","name":"CopyModeCommand","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"*string","doc":{"summary":"CopyModeCommand sends a tmux copy-mode command instead of Command. A nonnil empty string remains an explicit operand."},"source":{"file":"tmux/pane_input.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.CopyModeCommand","product":"core","slug":"tmux-sendkeysrequest-copymodecommand"},{"id":"tmux.SendKeysRequest.Repeat","name":"Repeat","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"int","doc":{"summary":"Repeat repeats the key input a positive number of times. Zero omits the repeat count."},"source":{"file":"tmux/pane_input.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.Repeat","product":"core","slug":"tmux-sendkeysrequest-repeat"},{"id":"tmux.SendKeysRequest.ExpandFormats","name":"ExpandFormats","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"ExpandFormats asks tmux to expand format expressions in key operands."},"source":{"file":"tmux/pane_input.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.ExpandFormats","product":"core","slug":"tmux-sendkeysrequest-expandformats"},{"id":"tmux.SendKeysRequest.HexKeys","name":"HexKeys","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"HexKeys interprets key operands as hexadecimal ASCII values and takes precedence over Literal."},"source":{"file":"tmux/pane_input.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.HexKeys","product":"core","slug":"tmux-sendkeysrequest-hexkeys"},{"id":"tmux.SendKeysRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the client used by KeyName. Zero leaves client selection to tmux; without KeyName it does not redirect pane input."},"source":{"file":"tmux/pane_input.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.TargetClient","product":"core","slug":"tmux-sendkeysrequest-targetclient"},{"id":"tmux.SendKeysRequest.KeyName","name":"KeyName","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"KeyName routes keys through the selected client's key table rather than delivering them to the pane."},"source":{"file":"tmux/pane_input.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeysRequest.KeyName","product":"core","slug":"tmux-sendkeysrequest-keyname"},{"id":"tmux.SendKeySequenceRequest","name":"SendKeySequenceRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SendKeySequenceRequest configures ordered pane key delivery. Keys must contain at least one nonempty operand. SendKeySequence copies Keys before I/O; callers must not mutate it concurrently with the call."},"source":{"file":"tmux/pane_input.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeySequenceRequest","product":"core","slug":"tmux-sendkeysequencerequest"},{"id":"tmux.SendKeySequenceRequest.Keys","name":"Keys","kind":"attribute","modifiers":[],"parent":"tmux.SendKeySequenceRequest","signatures":[],"type":"[]string","doc":{"summary":"Keys are tmux key names sent in order."},"source":{"file":"tmux/pane_input.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeySequenceRequest.Keys","product":"core","slug":"tmux-sendkeysequencerequest-keys"},{"id":"tmux.SendKeySequenceRequest.Literal","name":"Literal","kind":"attribute","modifiers":[],"parent":"tmux.SendKeySequenceRequest","signatures":[],"type":"bool","doc":{"summary":"Literal treats every key as literal UTF-8 instead of a tmux key name."},"source":{"file":"tmux/pane_input.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SendKeySequenceRequest.Literal","product":"core","slug":"tmux-sendkeysequencerequest-literal"},{"id":"tmux.Pane.SendKeySequence","name":"SendKeySequence","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SendKeySequenceRequest"}],"returns":"error"}],"doc":{"summary":"SendKeySequence sends the requested keys to the receiver's exact linked pane in one tmux command. It does not append Enter. Literal changes tmux key parsing but does not bypass interpretation by the pane's application.","body":"A returned error does not establish how many keys tmux delivered."},"source":{"file":"tmux/pane_input.go","line":68,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SendKeySequence","product":"core","slug":"tmux-pane-sendkeysequence"},{"id":"tmux.Pane.SendKeys","name":"SendKeys","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SendKeysRequest"}],"returns":"error"}],"doc":{"summary":"SendKeys invokes tmux send-keys with the receiver's exact linked session-window-pane target. This is tmux key input, not shell execution: Literal only changes tmux key parsing, and any delivered text may still be interpreted by the pane's application. KeyName routes through a client's key table instead of delivering to the pane.","body":"KeyName and TargetClient require tmux 3.4 and follow [UnsupportedPolicy].\n\nA completed nonzero exit or stderr, from either the Command send or the\nseparate Enter, becomes a redacted [CommandError]: Command may carry a\ncaller's secret, so only tmux's exit code is retained. Transport and\ncontext errors are delivery-ambiguous, including between Command and Enter."},"source":{"file":"tmux/pane_input.go","line":139,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SendKeys","product":"core","slug":"tmux-pane-sendkeys"},{"id":"tmux.Pane.Writer","name":"Writer","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"io.Writer"}],"doc":{"summary":"Writer returns the pane's keyboard as an [io.Writer]. Bytes written to it are typed into the pane literally, and each newline is the Enter key, so [fmt.Fprintln] submits a line as a person at the keyboard would. Text with no trailing newline is typed and left on the line.","body":"A write returns once tmux has taken the keys, before the pane's program has\nread them; the program interprets what arrives. A line with a trailing\nnewline costs two tmux commands, the text and a separate Enter; buffering\nwhole lines still costs far less than writing bytes one at a time."},"source":{"file":"tmux/pane_input.go","line":260,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Writer","product":"core","slug":"tmux-pane-writer"},{"id":"tmux.Pane.Enter","name":"Enter","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Enter sends the Enter key to the receiver's exact linked pane. A completed nonzero exit or stderr becomes a redacted [CommandError]; transport errors are delivery-ambiguous."},"source":{"file":"tmux/pane_input.go","line":291,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Enter","product":"core","slug":"tmux-pane-enter"},{"id":"tmux.PrefixKey","name":"PrefixKey","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PrefixKey selects the primary or secondary tmux prefix key. Its zero value selects the primary prefix."},"source":{"file":"tmux/pane_input.go","line":326,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PrefixKey","product":"core","slug":"tmux-prefixkey"},{"id":"tmux.PrefixPrimary","name":"PrefixPrimary","kind":"constant","modifiers":[],"signatures":[],"type":"PrefixKey","doc":{"summary":"PrefixPrimary selects tmux's primary prefix key."},"source":{"file":"tmux/pane_input.go","line":330,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PrefixPrimary","product":"core","slug":"tmux-prefixprimary"},{"id":"tmux.PrefixSecondary","name":"PrefixSecondary","kind":"constant","modifiers":[],"signatures":[],"type":"PrefixKey","doc":{"summary":"PrefixSecondary selects tmux's secondary prefix key."},"source":{"file":"tmux/pane_input.go","line":332,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PrefixSecondary","product":"core","slug":"tmux-prefixsecondary"},{"id":"tmux.Pane.SendPrefix","name":"SendPrefix","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"key","type":"PrefixKey"}],"returns":"error"}],"doc":{"summary":"SendPrefix sends a tmux prefix key to the receiver's exact linked pane. Unsupported PrefixKey values fail before execution. A completed command produces a [CommandError] only when tmux writes stderr; the library-created error retains only the exit code. Nonzero exits without stderr are ignored; transport errors are delivery-ambiguous."},"source":{"file":"tmux/pane_input.go","line":340,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.SendPrefix","product":"core","slug":"tmux-pane-sendprefix"},{"id":"tmux.ClearHistoryRequest","name":"ClearHistoryRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClearHistoryRequest configures pane history clearing. Its zero value clears scrollback without requesting hyperlink cleanup."},"source":{"file":"tmux/pane_input.go","line":360,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClearHistoryRequest","product":"core","slug":"tmux-clearhistoryrequest"},{"id":"tmux.ClearHistoryRequest.ResetHyperlinks","name":"ResetHyperlinks","kind":"attribute","modifiers":[],"parent":"tmux.ClearHistoryRequest","signatures":[],"type":"bool","doc":{"summary":"ResetHyperlinks also removes hyperlinks. It requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/pane_input.go","line":363,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ClearHistoryRequest.ResetHyperlinks","product":"core","slug":"tmux-clearhistoryrequest-resethyperlinks"},{"id":"tmux.Pane.ClearHistory","name":"ClearHistory","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ClearHistoryRequest"}],"returns":"error"}],"doc":{"summary":"ClearHistory removes scrollback from the receiver's exact linked pane. ResetHyperlinks triggers a version probe before mutation. A completed command produces a redacted [CommandError] only for stderr; nonzero exits without stderr are ignored. Accepted changes are not rolled back."},"source":{"file":"tmux/pane_input.go","line":370,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ClearHistory","product":"core","slug":"tmux-pane-clearhistory"},{"id":"tmux.Pane.Clear","name":"Clear","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Clear types the text \"reset\" and then Enter into the receiver's exact linked pane, the way a person at the keyboard would. Whatever is running reads it: a shell runs reset(1), and an editor receives the word. Use [Pane.Reset] or [Pane.ClearHistory] to act on the pane itself rather than on its program. A transport error may leave the text delivered without Enter."},"source":{"file":"tmux/pane_input.go","line":427,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Clear","product":"core","slug":"tmux-pane-clear"},{"id":"tmux.Pane.Reset","name":"Reset","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Reset submits one tmux command list that resets terminal state and then clears history for the exact linked pane. The mutations are not atomic and may be partial. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored. Transport errors are delivery-ambiguous."},"source":{"file":"tmux/pane_input.go","line":437,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Reset","product":"core","slug":"tmux-pane-reset"},{"id":"tmux.CopyModeRequest","name":"CopyModeRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CopyModeRequest configures tmux copy mode. Its zero value enters copy mode on the receiver without scrolling. Fields may be combined. tmux resolves the receiver and optional SourcePane before processing Cancel, so a stale target can prevent reset. After resolution, Cancel takes precedence over other actions, though SourcePane validation and the PageDown version probe still occur first."},"source":{"file":"tmux/pane_modes.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeRequest","product":"core","slug":"tmux-copymoderequest"},{"id":"tmux.CopyModeRequest.ScrollUp","name":"ScrollUp","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"ScrollUp enters copy mode one page above the current position."},"source":{"file":"tmux/pane_modes.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeRequest.ScrollUp","product":"core","slug":"tmux-copymoderequest-scrollup"},{"id":"tmux.CopyModeRequest.ExitOnBottom","name":"ExitOnBottom","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"ExitOnBottom makes copy mode exit after scrolling back to the visible screen, until another non-scrolling key disables that behavior."},"source":{"file":"tmux/pane_modes.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeRequest.ExitOnBottom","product":"core","slug":"tmux-copymoderequest-exitonbottom"},{"id":"tmux.CopyModeRequest.MouseDrag","name":"MouseDrag","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"MouseDrag begins a copy-mode mouse drag and is meaningful from a mouse binding."},"source":{"file":"tmux/pane_modes.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeRequest.MouseDrag","product":"core","slug":"tmux-copymoderequest-mousedrag"},{"id":"tmux.CopyModeRequest.PageDown","name":"PageDown","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"PageDown enters copy mode one page below the current position. It requires tmux 3.5 and follows UnsupportedPolicy. Its version probe still occurs when Cancel is set."},"source":{"file":"tmux/pane_modes.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeRequest.PageDown","product":"core","slug":"tmux-copymoderequest-pagedown"},{"id":"tmux.CopyModeRequest.SourcePane","name":"SourcePane","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"PaneID","doc":{"summary":"SourcePane selects a stable pane whose content is copied while the receiver remains the pane placed in copy mode. Zero uses the receiver. A nonzero value is validated by the library and resolved by tmux even when Cancel is set; a stale or nonexistent pane can prevent cancellation."},"source":{"file":"tmux/pane_modes.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeRequest.SourcePane","product":"core","slug":"tmux-copymoderequest-sourcepane"},{"id":"tmux.CopyModeRequest.Cancel","name":"Cancel","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"Cancel exits copy mode and any other active pane mode after tmux resolves the receiver and optional SourcePane. A resolution failure prevents the reset; after successful resolution, tmux ignores the other action fields."},"source":{"file":"tmux/pane_modes.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CopyModeRequest.Cancel","product":"core","slug":"tmux-copymoderequest-cancel"},{"id":"tmux.TreeSortOrder","name":"TreeSortOrder","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TreeSortOrder selects one initial tmux choose-tree ordering. Its zero value leaves tmux's configured ordering unchanged."},"source":{"file":"tmux/pane_modes.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TreeSortOrder","product":"core","slug":"tmux-treesortorder"},{"id":"tmux.TreeSortDefault","name":"TreeSortDefault","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortDefault leaves the configured choose-tree ordering unchanged."},"source":{"file":"tmux/pane_modes.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TreeSortDefault","product":"core","slug":"tmux-treesortdefault"},{"id":"tmux.TreeSortIndex","name":"TreeSortIndex","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortIndex orders tree entries by index."},"source":{"file":"tmux/pane_modes.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TreeSortIndex","product":"core","slug":"tmux-treesortindex"},{"id":"tmux.TreeSortName","name":"TreeSortName","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortName orders tree entries by name."},"source":{"file":"tmux/pane_modes.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TreeSortName","product":"core","slug":"tmux-treesortname"},{"id":"tmux.TreeSortTime","name":"TreeSortTime","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortTime orders tree entries by activity time."},"source":{"file":"tmux/pane_modes.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TreeSortTime","product":"core","slug":"tmux-treesorttime"},{"id":"tmux.TreeSortSize","name":"TreeSortSize","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortSize orders tree entries by size."},"source":{"file":"tmux/pane_modes.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TreeSortSize","product":"core","slug":"tmux-treesortsize"},{"id":"tmux.ChooseTreeRequest","name":"ChooseTreeRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ChooseTreeRequest configures the interactive session and window chooser. Its zero value uses tmux defaults. Format and Filter are copied before execution and must not be mutated concurrently."},"source":{"file":"tmux/pane_modes.go","line":59,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ChooseTreeRequest","product":"core","slug":"tmux-choosetreerequest"},{"id":"tmux.ChooseTreeRequest.SessionsCollapsed","name":"SessionsCollapsed","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"bool","doc":{"summary":"SessionsCollapsed starts with session nodes collapsed."},"source":{"file":"tmux/pane_modes.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ChooseTreeRequest.SessionsCollapsed","product":"core","slug":"tmux-choosetreerequest-sessionscollapsed"},{"id":"tmux.ChooseTreeRequest.WindowsCollapsed","name":"WindowsCollapsed","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"bool","doc":{"summary":"WindowsCollapsed starts with window nodes collapsed."},"source":{"file":"tmux/pane_modes.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ChooseTreeRequest.WindowsCollapsed","product":"core","slug":"tmux-choosetreerequest-windowscollapsed"},{"id":"tmux.ChooseTreeRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"*string","doc":{"summary":"Format is a tmux format expression evaluated for each tree item. Nil leaves the configured format; nonnil empty remains an explicit format."},"source":{"file":"tmux/pane_modes.go","line":66,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ChooseTreeRequest.Format","product":"core","slug":"tmux-choosetreerequest-format"},{"id":"tmux.ChooseTreeRequest.Filter","name":"Filter","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"*TmuxFilter","doc":{"summary":"Filter is a tmux format expression whose truth value selects tree items. Nil omits filtering; nonnil empty remains an explicit expression."},"source":{"file":"tmux/pane_modes.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ChooseTreeRequest.Filter","product":"core","slug":"tmux-choosetreerequest-filter"},{"id":"tmux.ChooseTreeRequest.Sort","name":"Sort","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"TreeSortOrder","doc":{"summary":"Sort selects the initial ordering. Unknown values are rejected before execution."},"source":{"file":"tmux/pane_modes.go","line":72,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ChooseTreeRequest.Sort","product":"core","slug":"tmux-choosetreerequest-sort"},{"id":"tmux.ChooseTreeRequest.Reverse","name":"Reverse","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"bool","doc":{"summary":"Reverse reverses the initial tree ordering."},"source":{"file":"tmux/pane_modes.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ChooseTreeRequest.Reverse","product":"core","slug":"tmux-choosetreerequest-reverse"},{"id":"tmux.ChooseTreeRequest.Zoom","name":"Zoom","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"bool","doc":{"summary":"Zoom zooms the chooser pane while tree mode is active."},"source":{"file":"tmux/pane_modes.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ChooseTreeRequest.Zoom","product":"core","slug":"tmux-choosetreerequest-zoom"},{"id":"tmux.FindWindowRequest","name":"FindWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"FindWindowRequest configures the interactive window search chooser. Match is a tmux search operand, not a shell command. The zero value searches with an empty glob using tmux's default name, title, and visible-content scopes."},"source":{"file":"tmux/pane_modes.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FindWindowRequest","product":"core","slug":"tmux-findwindowrequest"},{"id":"tmux.FindWindowRequest.Match","name":"Match","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"string","doc":{"summary":"Match is the glob pattern, or regular expression when Regex is true."},"source":{"file":"tmux/pane_modes.go","line":84,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FindWindowRequest.Match","product":"core","slug":"tmux-findwindowrequest-match"},{"id":"tmux.FindWindowRequest.MatchContent","name":"MatchContent","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"MatchContent restricts matching to visible window content, not history."},"source":{"file":"tmux/pane_modes.go","line":86,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FindWindowRequest.MatchContent","product":"core","slug":"tmux-findwindowrequest-matchcontent"},{"id":"tmux.FindWindowRequest.CaseInsensitive","name":"CaseInsensitive","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"CaseInsensitive makes matching ignore case."},"source":{"file":"tmux/pane_modes.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FindWindowRequest.CaseInsensitive","product":"core","slug":"tmux-findwindowrequest-caseinsensitive"},{"id":"tmux.FindWindowRequest.MatchName","name":"MatchName","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"MatchName restricts matching to window names."},"source":{"file":"tmux/pane_modes.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FindWindowRequest.MatchName","product":"core","slug":"tmux-findwindowrequest-matchname"},{"id":"tmux.FindWindowRequest.Regex","name":"Regex","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Regex interprets Match as a regular expression instead of a glob."},"source":{"file":"tmux/pane_modes.go","line":92,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FindWindowRequest.Regex","product":"core","slug":"tmux-findwindowrequest-regex"},{"id":"tmux.FindWindowRequest.MatchTitle","name":"MatchTitle","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"MatchTitle restricts matching to window titles."},"source":{"file":"tmux/pane_modes.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FindWindowRequest.MatchTitle","product":"core","slug":"tmux-findwindowrequest-matchtitle"},{"id":"tmux.DisplayPanesRequest","name":"DisplayPanesRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DisplayPanesRequest configures pane-number display for tmux's current client and does not inherit the Pane target. Duration is read during the call, not retained, and must not be mutated concurrently."},"source":{"file":"tmux/pane_modes.go","line":100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPanesRequest","product":"core","slug":"tmux-displaypanesrequest"},{"id":"tmux.DisplayPanesRequest.Duration","name":"Duration","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPanesRequest","signatures":[],"type":"*int","doc":{"summary":"Duration is the display time in milliseconds. Nil uses tmux's display-panes-time option; zero waits for a key press. Negative values are rejected before execution."},"source":{"file":"tmux/pane_modes.go","line":104,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPanesRequest.Duration","product":"core","slug":"tmux-displaypanesrequest-duration"},{"id":"tmux.DisplayPanesRequest.NoSelect","name":"NoSelect","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPanesRequest","signatures":[],"type":"bool","doc":{"summary":"NoSelect prevents number keys from selecting a pane, so the display closes only after its duration. With Duration set to zero, it may remain until the context is canceled."},"source":{"file":"tmux/pane_modes.go","line":108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPanesRequest.NoSelect","product":"core","slug":"tmux-displaypanesrequest-noselect"},{"id":"tmux.Pane.CopyMode","name":"CopyMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"CopyModeRequest"}],"returns":"error"}],"doc":{"summary":"CopyMode enters or cancels copy mode using the receiver's exact linked session-window-pane target. PageDown requires tmux 3.5 and follows [UnsupportedPolicy]. A version-probe error stops the operation. tmux resolves the receiver and optional SourcePane before processing Cancel; a stale target can therefore fail without resetting the current mode. Cancel then takes precedence over other actions.","body":"Only stderr produces a redacted [CommandError]; nonzero exits without stderr\nare ignored. Accepted mode changes are not rolled back."},"source":{"file":"tmux/pane_modes.go","line":120,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CopyMode","product":"core","slug":"tmux-pane-copymode"},{"id":"tmux.Pane.ClockMode","name":"ClockMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"ClockMode enters clock mode using the receiver's exact linked target."},"source":{"file":"tmux/pane_modes.go","line":171,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ClockMode","product":"core","slug":"tmux-pane-clockmode"},{"id":"tmux.Pane.ChooseBuffer","name":"ChooseBuffer","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"ChooseBuffer enters tmux's interactive buffer chooser using the receiver's exact linked target. It requires an attached client."},"source":{"file":"tmux/pane_modes.go","line":177,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ChooseBuffer","product":"core","slug":"tmux-pane-choosebuffer"},{"id":"tmux.Pane.ChooseClient","name":"ChooseClient","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"ChooseClient enters tmux's interactive client chooser using the receiver's exact linked target. It requires an attached client."},"source":{"file":"tmux/pane_modes.go","line":183,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ChooseClient","product":"core","slug":"tmux-pane-chooseclient"},{"id":"tmux.Pane.CustomizeMode","name":"CustomizeMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CustomizeMode enters tmux's interactive option browser using the receiver's exact linked target. It requires an attached client."},"source":{"file":"tmux/pane_modes.go","line":189,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.CustomizeMode","product":"core","slug":"tmux-pane-customizemode"},{"id":"tmux.Pane.ChooseTree","name":"ChooseTree","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ChooseTreeRequest"}],"returns":"error"}],"doc":{"summary":"ChooseTree enters tmux's interactive session, window, and pane chooser using the receiver's exact linked target. It requires an attached client. Format and Filter are tmux expressions; neither is interpreted by a shell. Unsupported sort values fail before execution. Only stderr produces a redacted [CommandError]; transport errors may leave tree mode active."},"source":{"file":"tmux/pane_modes.go","line":198,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ChooseTree","product":"core","slug":"tmux-pane-choosetree"},{"id":"tmux.Pane.FindWindow","name":"FindWindow","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"FindWindowRequest"}],"returns":"error"}],"doc":{"summary":"FindWindow opens a tree chooser filtered by Match using the receiver's exact linked target. It requires an attached client. Match is passed as one tmux search operand and protected from leading-dash option parsing; it is not a tmux format or shell command. Only stderr produces a redacted [CommandError]; transport errors may leave the chooser open."},"source":{"file":"tmux/pane_modes.go","line":255,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.FindWindow","product":"core","slug":"tmux-pane-findwindow"},{"id":"tmux.Pane.DisplayPanes","name":"DisplayPanes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayPanesRequest"}],"returns":"error"}],"doc":{"summary":"DisplayPanes displays pane numbers for tmux's current client and waits for the indicator to close. It is client-scoped: the receiver supplies only the server connection and no pane target. A zero request uses tmux's configured duration and permits number-key selection.","body":"Only stderr produces a redacted [CommandError]; nonzero exits without stderr\nare ignored. Cancellation cannot revoke an accepted display."},"source":{"file":"tmux/pane_modes.go","line":291,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.DisplayPanes","product":"core","slug":"tmux-pane-displaypanes"},{"id":"tmux.DisplayPopupRequest","name":"DisplayPopupRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DisplayPopupRequest configures a popup overlay. Pointer and map values are copied before I/O and must not be mutated concurrently. Pointer fields distinguish omission from an explicit empty value, with the Command and StartDirectory behavior documented on those fields.","body":"CloseOnExit and CloseOnSuccess are mutually exclusive. CloseExisting asks\ntmux only to close the existing overlay, so the remaining fields do not\ncreate a replacement. NoBorder makes BorderLines ineffective. When modifying\nan existing popup, NoKeys clears its configured automatic-close flags before\ntmux applies CloseOnExit, CloseOnSuccess, and CloseOnAnyKey from this request.\nNoKeys does not disable keyboard input."},"source":{"file":"tmux/pane_popup.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest","product":"core","slug":"tmux-displaypopuprequest"},{"id":"tmux.DisplayPopupRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Command is interpreted by tmux as a shell command. Nil lets tmux use default-command and then its default shell; nonnil empty is passed explicitly and tmux resolves it directly to the default shell."},"source":{"file":"tmux/pane_popup.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.Command","product":"core","slug":"tmux-displaypopuprequest-command"},{"id":"tmux.DisplayPopupRequest.CloseOnExit","name":"CloseOnExit","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"CloseOnExit closes the overlay whenever Command exits."},"source":{"file":"tmux/pane_popup.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.CloseOnExit","product":"core","slug":"tmux-displaypopuprequest-closeonexit"},{"id":"tmux.DisplayPopupRequest.CloseOnSuccess","name":"CloseOnSuccess","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"CloseOnSuccess closes the overlay only when Command exits successfully."},"source":{"file":"tmux/pane_popup.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.CloseOnSuccess","product":"core","slug":"tmux-displaypopuprequest-closeonsuccess"},{"id":"tmux.DisplayPopupRequest.CloseExisting","name":"CloseExisting","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"CloseExisting closes the selected client's existing overlay and prevents this request from creating a replacement."},"source":{"file":"tmux/pane_popup.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.CloseExisting","product":"core","slug":"tmux-displaypopuprequest-closeexisting"},{"id":"tmux.DisplayPopupRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the client that receives the overlay; zero lets tmux choose. tmux 3.8 and later refuses to host a popup on a control-mode client, which cannot render an overlay, so an explicit control-mode TargetClient is rejected on those versions rather than left as the silent no-op tmux itself returns."},"source":{"file":"tmux/pane_popup.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.TargetClient","product":"core","slug":"tmux-displaypopuprequest-targetclient"},{"id":"tmux.DisplayPopupRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Width is an explicit cell count or percentage and may contain tmux format expressions. Nil lets tmux choose the default width."},"source":{"file":"tmux/pane_popup.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.Width","product":"core","slug":"tmux-displaypopuprequest-width"},{"id":"tmux.DisplayPopupRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Height is an explicit cell count or percentage and may contain tmux format expressions. Nil lets tmux choose the default height."},"source":{"file":"tmux/pane_popup.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.Height","product":"core","slug":"tmux-displaypopuprequest-height"},{"id":"tmux.DisplayPopupRequest.X","name":"X","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"X is a tmux popup position expression and may contain tmux formats. Nil lets tmux choose the horizontal position."},"source":{"file":"tmux/pane_popup.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.X","product":"core","slug":"tmux-displaypopuprequest-x"},{"id":"tmux.DisplayPopupRequest.Y","name":"Y","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Y is a tmux popup position expression and may contain tmux formats. Nil lets tmux choose the vertical position."},"source":{"file":"tmux/pane_popup.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.Y","product":"core","slug":"tmux-displaypopuprequest-y"},{"id":"tmux.DisplayPopupRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"StartDirectory selects the popup working directory. Nil omits the option; nonnil empty is normalized to \".\". The library expands a leading local ~ before tmux expands formats in the resulting value."},"source":{"file":"tmux/pane_popup.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.StartDirectory","product":"core","slug":"tmux-displaypopuprequest-startdirectory"},{"id":"tmux.DisplayPopupRequest.Title","name":"Title","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Title is the popup title format. Nil leaves the tmux default."},"source":{"file":"tmux/pane_popup.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.Title","product":"core","slug":"tmux-displaypopuprequest-title"},{"id":"tmux.DisplayPopupRequest.BorderLines","name":"BorderLines","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"BorderLines selects tmux's border-line style. NoBorder makes it ineffective."},"source":{"file":"tmux/pane_popup.go","line":72,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.BorderLines","product":"core","slug":"tmux-displaypopuprequest-borderlines"},{"id":"tmux.DisplayPopupRequest.Style","name":"Style","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Style selects the tmux style for the popup interior."},"source":{"file":"tmux/pane_popup.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.Style","product":"core","slug":"tmux-displaypopuprequest-style"},{"id":"tmux.DisplayPopupRequest.BorderStyle","name":"BorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"BorderStyle selects the tmux style for the popup border."},"source":{"file":"tmux/pane_popup.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.BorderStyle","product":"core","slug":"tmux-displaypopuprequest-borderstyle"},{"id":"tmux.DisplayPopupRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment adds validated popup environment entries. Nil and an empty map add none; entries are sent in lexical key order."},"source":{"file":"tmux/pane_popup.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.Environment","product":"core","slug":"tmux-displaypopuprequest-environment"},{"id":"tmux.DisplayPopupRequest.NoBorder","name":"NoBorder","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"NoBorder removes the popup border and makes BorderLines ineffective."},"source":{"file":"tmux/pane_popup.go","line":81,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.NoBorder","product":"core","slug":"tmux-displaypopuprequest-noborder"},{"id":"tmux.DisplayPopupRequest.CloseOnAnyKey","name":"CloseOnAnyKey","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"CloseOnAnyKey lets a nonmouse, nonpaste key dismiss the popup after its command has exited. It does not dismiss the popup while the job is active; tmux continues to send keys to that job."},"source":{"file":"tmux/pane_popup.go","line":85,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.CloseOnAnyKey","product":"core","slug":"tmux-displaypopuprequest-closeonanykey"},{"id":"tmux.DisplayPopupRequest.NoKeys","name":"NoKeys","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"NoKeys clears automatic-close flags previously configured on an existing popup. Same-request close flags are then applied, and key input remains enabled."},"source":{"file":"tmux/pane_popup.go","line":89,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayPopupRequest.NoKeys","product":"core","slug":"tmux-displaypopuprequest-nokeys"},{"id":"tmux.Pane.DisplayPopup","name":"DisplayPopup","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayPopupRequest"}],"returns":"error"}],"doc":{"summary":"DisplayPopup displays an overlay on the selected client and waits until it closes after command exit or user dismissal. A zero request starts tmux's default command or default shell and may wait indefinitely. The API exposes no popup process handle, stdout, or child exit status.","body":"The command carries the receiver's exact linked session-window-pane target,\nwhich supplies format and working-directory context. TargetClient selects\nthe overlay client; it does not turn the operation into pane delivery. tmux\ninterprets Command as a shell command; outer-parser escaping does not quote\nor neutralize that inner command.\n\nTitle, BorderLines, Style, BorderStyle, Environment, and NoBorder require\ntmux 3.3. CloseOnAnyKey and NoKeys require tmux 3.6. Unsupported fields follow\n[UnsupportedPolicy]. On tmux 3.8 and later, an explicit TargetClient that\nresolves to a control-mode client returns [ErrInvalidServerCommandRequest]\nunless CloseExisting is set: tmux itself answers that combination exactly\nas it answers success, so nothing on the wire would otherwise say the\npopup never ran. CloseExisting is exempt because tmux handles it before\nthat refusal on every version, clearing whatever overlay the target has -\nnothing, for a control-mode client - without creating anything either way.\n\nInvalid fields fail before display. Only stderr produces a redacted\n[CommandError]; nonzero exits without stderr are ignored. Cancellation cannot\ndismiss an accepted popup, which may remain visible."},"source":{"file":"tmux/pane_popup.go","line":137,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.DisplayPopup","product":"core","slug":"tmux-pane-displaypopup"},{"id":"tmux.PasteBufferRequest","name":"PasteBufferRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PasteBufferRequest configures one tmux paste-buffer operation. Its zero value pastes the top buffer, replaces linefeeds with tmux's default carriage-return separator, and uses the version's default control-character handling. Pointer values are copied before I/O and must not be mutated concurrently."},"source":{"file":"tmux/pane_process.go","line":9,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PasteBufferRequest","product":"core","slug":"tmux-pastebufferrequest"},{"id":"tmux.PasteBufferRequest.BufferName","name":"BufferName","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"*string","doc":{"summary":"BufferName selects a named tmux buffer. Nil selects the top buffer; nonnil empty remains an explicit buffer name."},"source":{"file":"tmux/pane_process.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PasteBufferRequest.BufferName","product":"core","slug":"tmux-pastebufferrequest-buffername"},{"id":"tmux.PasteBufferRequest.DeleteAfter","name":"DeleteAfter","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"bool","doc":{"summary":"DeleteAfter asks tmux to delete an existing selected buffer after processing it. Deletion does not prove bytes reached a pane whose input may be disabled."},"source":{"file":"tmux/pane_process.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PasteBufferRequest.DeleteAfter","product":"core","slug":"tmux-pastebufferrequest-deleteafter"},{"id":"tmux.PasteBufferRequest.LinefeedSeparator","name":"LinefeedSeparator","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"bool","doc":{"summary":"LinefeedSeparator preserves linefeeds instead of replacing them with Separator or tmux's default carriage return."},"source":{"file":"tmux/pane_process.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PasteBufferRequest.LinefeedSeparator","product":"core","slug":"tmux-pastebufferrequest-linefeedseparator"},{"id":"tmux.PasteBufferRequest.Bracket","name":"Bracket","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"bool","doc":{"summary":"Bracket surrounds the paste with bracketed-paste control codes when the pane application has requested bracketed paste mode."},"source":{"file":"tmux/pane_process.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PasteBufferRequest.Bracket","product":"core","slug":"tmux-pastebufferrequest-bracket"},{"id":"tmux.PasteBufferRequest.Separator","name":"Separator","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"*string","doc":{"summary":"Separator replaces linefeeds. Nil uses tmux's default carriage return; nonnil empty removes linefeeds. LinefeedSeparator takes precedence."},"source":{"file":"tmux/pane_process.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PasteBufferRequest.Separator","product":"core","slug":"tmux-pastebufferrequest-separator"},{"id":"tmux.PasteBufferRequest.NoVis","name":"NoVis","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"bool","doc":{"summary":"NoVis requests raw bytes and requires tmux 3.7. Older versions already paste raw bytes; see UnsupportedPolicy."},"source":{"file":"tmux/pane_process.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PasteBufferRequest.NoVis","product":"core","slug":"tmux-pastebufferrequest-novis"},{"id":"tmux.PipePaneRequest","name":"PipePaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PipePaneRequest configures a pane pipe. Its flags may be combined. Command is copied before I/O and must not be mutated concurrently."},"source":{"file":"tmux/pane_process.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PipePaneRequest","product":"core","slug":"tmux-pipepanerequest"},{"id":"tmux.PipePaneRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.PipePaneRequest","signatures":[],"type":"*string","doc":{"summary":"Command is a shell command for tmux's pipe process. Nil closes the current pipe; nonnil empty is an explicit operand that tmux also treats as stop."},"source":{"file":"tmux/pane_process.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PipePaneRequest.Command","product":"core","slug":"tmux-pipepanerequest-command"},{"id":"tmux.PipePaneRequest.OutputOnly","name":"OutputOnly","kind":"attribute","modifiers":[],"parent":"tmux.PipePaneRequest","signatures":[],"type":"bool","doc":{"summary":"OutputOnly connects pane output to the pipe command's standard input. When neither direction is set, tmux uses this direction by default."},"source":{"file":"tmux/pane_process.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PipePaneRequest.OutputOnly","product":"core","slug":"tmux-pipepanerequest-outputonly"},{"id":"tmux.PipePaneRequest.InputOnly","name":"InputOnly","kind":"attribute","modifiers":[],"parent":"tmux.PipePaneRequest","signatures":[],"type":"bool","doc":{"summary":"InputOnly connects the pipe command's standard output to pane input."},"source":{"file":"tmux/pane_process.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PipePaneRequest.InputOnly","product":"core","slug":"tmux-pipepanerequest-inputonly"},{"id":"tmux.PipePaneRequest.Toggle","name":"Toggle","kind":"attribute","modifiers":[],"parent":"tmux.PipePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Toggle closes an existing pipe or opens Command when no pipe exists."},"source":{"file":"tmux/pane_process.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PipePaneRequest.Toggle","product":"core","slug":"tmux-pipepanerequest-toggle"},{"id":"tmux.Pane.Respawn","name":"Respawn","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RespawnRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Respawn restarts the process in the receiver's exact linked pane on tmux 3.2a or newer. Command, when present, is passed as one tmux shell-command operand; Go neither executes it locally nor adds inner-shell quoting. Final semicolon protection applies only to tmux's outer command parser. See [RespawnRequest] for zero-value, directory, environment, and Kill behavior.","body":"Respawn refreshes by PaneID, so the returned canonical [Pane] may carry a\ndifferent linked-session or winlink context. The process may be restarted\nbefore refresh fails; in that case Respawn returns the original receiver and\nthe refresh error. Earlier failures return zero. Completed stderr produces a\nredacted [CommandError]; a nonzero exit without stderr is followed by refresh."},"source":{"file":"tmux/pane_process.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Respawn","product":"core","slug":"tmux-pane-respawn"},{"id":"tmux.Pane.PasteBuffer","name":"PasteBuffer","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PasteBufferRequest"}],"returns":"error"}],"doc":{"summary":"PasteBuffer pastes a named or top buffer into the receiver's exact linked pane. DeleteAfter requests deletion after tmux processes an existing buffer; an exited target or missing named buffer fails before deletion, while deletion after disabled pane input does not prove byte delivery.","body":"NoVis requires tmux 3.7 and follows [UnsupportedPolicy]; older versions\nalready paste raw bytes. Only stderr produces a redacted [CommandError];\nnonzero exits without stderr are ignored. Accepted paste or deletion effects\nare not rolled back."},"source":{"file":"tmux/pane_process.go","line":134,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.PasteBuffer","product":"core","slug":"tmux-pane-pastebuffer"},{"id":"tmux.Pane.Pipe","name":"Pipe","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PipePaneRequest"}],"returns":"error"}],"doc":{"summary":"Pipe starts, toggles, or stops piping for the receiver's exact linked pane. tmux expands formats and time formats in Command before running it with sh -c. The library's protection for a final semicolon applies only to tmux's outer command parser; it does not quote or neutralize the child shell.","body":"A nil Command, and an explicit empty Command under tmux semantics, stops the\ncurrent pipe. Successful return means tmux installed, toggled, or stopped the\npipe; it does not report child-shell success or lifetime. Only stderr produces\na redacted [CommandError]. Accepted pipe changes are not rolled back."},"source":{"file":"tmux/pane_process.go","line":207,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Pipe","product":"core","slug":"tmux-pane-pipe"},{"id":"tmux.MovePaneRequest","name":"MovePaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MovePaneRequest configures move-pane on tmux 3.2a or later. Its zero value is invalid: exactly one complete TargetPane or TargetWindow handle is required. Cross-object handles must be proven to share a daemon through connection state or the same nonempty SocketPath; matching socket names alone are insufficient. Size and Percentage are mutually exclusive. Invalid enum, target, size, and percentage values are rejected before execution.","body":"Size pointers are read during the call and not retained; nil omits the mode\nand nonnil is explicit. Do not mutate them concurrently."},"source":{"file":"tmux/pane_relocate.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MovePaneRequest","product":"core","slug":"tmux-movepanerequest"},{"id":"tmux.MovePaneRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"Pane","doc":{"summary":"TargetPane selects an exact destination pane; a zero Pane omits it."},"source":{"file":"tmux/pane_relocate.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MovePaneRequest.TargetPane","product":"core","slug":"tmux-movepanerequest-targetpane"},{"id":"tmux.MovePaneRequest.TargetWindow","name":"TargetWindow","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"Window","doc":{"summary":"TargetWindow selects an exact destination winlink; a zero Window omits it."},"source":{"file":"tmux/pane_relocate.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MovePaneRequest.TargetWindow","product":"core","slug":"tmux-movepanerequest-targetwindow"},{"id":"tmux.MovePaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets tmux make the moved pane active in the destination winlink."},"source":{"file":"tmux/pane_relocate.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MovePaneRequest.Attach","product":"core","slug":"tmux-movepanerequest-attach"},{"id":"tmux.MovePaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"PaneDirection","doc":{"summary":"Direction selects placement relative to the destination; zero means below."},"source":{"file":"tmux/pane_relocate.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MovePaneRequest.Direction","product":"core","slug":"tmux-movepanerequest-direction"},{"id":"tmux.MovePaneRequest.FullWindow","name":"FullWindow","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"bool","doc":{"summary":"FullWindow lets the moved pane span the full destination window."},"source":{"file":"tmux/pane_relocate.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MovePaneRequest.FullWindow","product":"core","slug":"tmux-movepanerequest-fullwindow"},{"id":"tmux.MovePaneRequest.Size","name":"Size","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"*int","doc":{"summary":"Size selects a nonnegative absolute pane size; nil omits it."},"source":{"file":"tmux/pane_relocate.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MovePaneRequest.Size","product":"core","slug":"tmux-movepanerequest-size"},{"id":"tmux.MovePaneRequest.Percentage","name":"Percentage","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"*int","doc":{"summary":"Percentage selects a size from 0 through 100; nil omits it."},"source":{"file":"tmux/pane_relocate.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MovePaneRequest.Percentage","product":"core","slug":"tmux-movepanerequest-percentage"},{"id":"tmux.JoinPaneRequest","name":"JoinPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"JoinPaneRequest configures join-pane with the same target, cross-daemon, sizing, validation, and pointer-ownership rules as [MovePaneRequest]."},"source":{"file":"tmux/pane_relocate.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.JoinPaneRequest","product":"core","slug":"tmux-joinpanerequest"},{"id":"tmux.JoinPaneRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"Pane","doc":{"summary":"TargetPane selects an exact destination pane; a zero Pane omits it."},"source":{"file":"tmux/pane_relocate.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.JoinPaneRequest.TargetPane","product":"core","slug":"tmux-joinpanerequest-targetpane"},{"id":"tmux.JoinPaneRequest.TargetWindow","name":"TargetWindow","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"Window","doc":{"summary":"TargetWindow selects an exact destination winlink; a zero Window omits it."},"source":{"file":"tmux/pane_relocate.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.JoinPaneRequest.TargetWindow","product":"core","slug":"tmux-joinpanerequest-targetwindow"},{"id":"tmux.JoinPaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets tmux make the joined pane active in the destination winlink."},"source":{"file":"tmux/pane_relocate.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.JoinPaneRequest.Attach","product":"core","slug":"tmux-joinpanerequest-attach"},{"id":"tmux.JoinPaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"PaneDirection","doc":{"summary":"Direction selects placement relative to the destination; zero means below."},"source":{"file":"tmux/pane_relocate.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.JoinPaneRequest.Direction","product":"core","slug":"tmux-joinpanerequest-direction"},{"id":"tmux.JoinPaneRequest.FullWindow","name":"FullWindow","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"bool","doc":{"summary":"FullWindow lets the joined pane span the full destination window."},"source":{"file":"tmux/pane_relocate.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.JoinPaneRequest.FullWindow","product":"core","slug":"tmux-joinpanerequest-fullwindow"},{"id":"tmux.JoinPaneRequest.Size","name":"Size","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Size selects a nonnegative absolute pane size; nil omits it."},"source":{"file":"tmux/pane_relocate.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.JoinPaneRequest.Size","product":"core","slug":"tmux-joinpanerequest-size"},{"id":"tmux.JoinPaneRequest.Percentage","name":"Percentage","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Percentage selects a size from 0 through 100; nil omits it."},"source":{"file":"tmux/pane_relocate.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.JoinPaneRequest.Percentage","product":"core","slug":"tmux-joinpanerequest-percentage"},{"id":"tmux.BreakPaneRequest","name":"BreakPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"BreakPaneRequest configures break-pane on tmux 3.2a or later. Its zero value moves the receiver to a detached new window with tmux's default name, except for the documented raw-version 3.7 workaround in [Pane.BreakPane]. Empty Name means omission and is validated before the version probe."},"source":{"file":"tmux/pane_relocate.go","line":59,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BreakPaneRequest","product":"core","slug":"tmux-breakpanerequest"},{"id":"tmux.BreakPaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.BreakPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets the new winlink become current in the receiver session."},"source":{"file":"tmux/pane_relocate.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BreakPaneRequest.Attach","product":"core","slug":"tmux-breakpanerequest-attach"},{"id":"tmux.BreakPaneRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.BreakPaneRequest","signatures":[],"type":"string","doc":{"summary":"Name requests the new window name; empty normally lets tmux choose."},"source":{"file":"tmux/pane_relocate.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BreakPaneRequest.Name","product":"core","slug":"tmux-breakpanerequest-name"},{"id":"tmux.Pane.Move","name":"Move","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"MovePaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Move relocates the receiver pane into one exact destination with tmux's move-pane command. Unless Attach is set, the destination's active-pane selection remains unchanged; Attach is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the destination SessionID and WindowID rather than by canonical ID-only refresh.","body":"Removing the sole pane destroys the emptied source window and all of its\nwinlinks. Affected source sessions preserve their current selection unless\nthat window was current, in which case they select another. A session left\nwithout windows is destroyed and detaches its clients.\n\nIf exact refresh fails after the command, Move returns a partial Pane with\nthe receiver PaneID and predicted destination context. Other failures return\nzero. Transport errors are delivery-ambiguous and no rollback is attempted."},"source":{"file":"tmux/pane_relocate.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Move","product":"core","slug":"tmux-pane-move"},{"id":"tmux.Pane.Join","name":"Join","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"JoinPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Join relocates the receiver with join-pane. Its selection, source-destruction, partial-result, and delivery behavior matches [Pane.Move]."},"source":{"file":"tmux/pane_relocate.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Join","product":"core","slug":"tmux-pane-join"},{"id":"tmux.Pane.BreakPane","name":"BreakPane","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"BreakPaneRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"BreakPane moves the receiver into a new window in its exact session. Attach lets that new winlink become current in the session; it is not a global client-focus guarantee. The returned [Window] is freshly materialized in the receiver SessionID rather than by canonical ID-only refresh.","body":"Before tmux 3.6, the sole-pane path may print no ID and retain WindowID; this\nmethod refreshes that identity. Raw version \"3.7\" alone uses a placeholder\nname and optional second rename; with an empty Name, the window may remain\nnamed \"libtmux\". Suffixed 3.7 releases do not use the workaround.\n\nAfter a reported ID, rename failure, or refresh failure, the partial result\ncarries the known WindowID and receiver session with Index -1. Earlier\nfailures return zero; no mutation is rolled back."},"source":{"file":"tmux/pane_relocate.go","line":119,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.BreakPane","product":"core","slug":"tmux-pane-breakpane"},{"id":"tmux.PaneText","name":"PaneText","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneText is what a pane wrote after an observation's baseline, as the text a person would read: escape sequences removed, UTF-8 joined across writes, and each carriage return or backspace that would overwrite text starting a new line, so nothing the program wrote is hidden."},"source":{"file":"tmux/pane_wait.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneText","product":"core","slug":"tmux-panetext"},{"id":"tmux.PaneText.Text","name":"Text","kind":"attribute","modifiers":[],"parent":"tmux.PaneText","signatures":[],"type":"string","doc":{"summary":"Text is the most recent output, up to a mebibyte."},"source":{"file":"tmux/pane_wait.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneText.Text","product":"core","slug":"tmux-panetext-text"},{"id":"tmux.PaneText.DroppedBytes","name":"DroppedBytes","kind":"attribute","modifiers":[],"parent":"tmux.PaneText","signatures":[],"type":"int","doc":{"summary":"DroppedBytes counts what was dropped from the front of Text to keep it within that bound."},"source":{"file":"tmux/pane_wait.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneText.DroppedBytes","product":"core","slug":"tmux-panetext-droppedbytes"},{"id":"tmux.PaneText.DroppedLines","name":"DroppedLines","kind":"attribute","modifiers":[],"parent":"tmux.PaneText","signatures":[],"type":"int","doc":{"summary":"DroppedLines counts the line ends among those dropped bytes."},"source":{"file":"tmux/pane_wait.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneText.DroppedLines","product":"core","slug":"tmux-panetext-droppedlines"},{"id":"tmux.PaneObservation.WaitFor","name":"WaitFor","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"match","type":"func(text string) bool"}],"returns":"(PaneText, error)"}],"doc":{"summary":"WaitFor reads what the pane writes after the observation's baseline and calls match with all of it each time the pane writes, until match reports true, ctx ends, or the observation is lost. It returns the text match accepted, or what was read before the error. tmux pushes each write as it happens, so nothing is polled.","body":"The baseline is not part of the text: check [PaneObservation.Baseline] for\nwhat was on screen already. A shell echoes what is typed into it, and the\necho is output like any other, so open the observation before typing and\nmatch on what the command prints rather than on the command itself.\n\nWrites that arrived together reach match once. Exactly one read may run at\na time, as for [PaneObservation.NextNotification], and a malformed\nnotification is skipped as [PaneObservation.Reader] skips it."},"source":{"file":"tmux/pane_wait.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneObservation.WaitFor","product":"core","slug":"tmux-paneobservation-waitfor"},{"id":"tmux.ErrPlan","name":"ErrPlan","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrPlan identifies a plan that cannot run as recorded. It is matched by errors.Is for [PlanError]."},"source":{"file":"tmux/plan.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrPlan","product":"core","slug":"tmux-errplan"},{"id":"tmux.PlanError","name":"PlanError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PlanError reports a plan this package refused before sending anything to tmux. It matches [ErrPlan] through errors.Is; callers can recover Step and Reason with errors.As."},"source":{"file":"tmux/plan.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanError","product":"core","slug":"tmux-planerror"},{"id":"tmux.PlanError.Step","name":"Step","kind":"attribute","modifiers":[],"parent":"tmux.PlanError","signatures":[],"type":"int","doc":{"summary":"Step is the zero-based index of the operation at fault."},"source":{"file":"tmux/plan.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanError.Step","product":"core","slug":"tmux-planerror-step"},{"id":"tmux.PlanError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.PlanError","signatures":[],"type":"string","doc":{"summary":"Reason describes what makes the plan unrunnable."},"source":{"file":"tmux/plan.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanError.Reason","product":"core","slug":"tmux-planerror-reason"},{"id":"tmux.PlanError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.PlanError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/plan.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanError.Error","product":"core","slug":"tmux-planerror-error"},{"id":"tmux.PlanError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.PlanError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes PlanError compatible with ErrPlan."},"source":{"file":"tmux/plan.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanError.Unwrap","product":"core","slug":"tmux-planerror-unwrap"},{"id":"tmux.Ref","name":"Ref","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Ref addresses an existing object or one an earlier [Plan] step will create. This permits forward construction without tmux I/O. The zero Ref addresses nothing and makes a targeted operation fail validation."},"source":{"file":"tmux/plan.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Ref","product":"core","slug":"tmux-ref"},{"id":"tmux.Session.Ref","name":"Ref","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"Ref"}],"doc":{"summary":"Ref returns a [Ref] addressing the receiver."},"source":{"file":"tmux/plan.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Ref","product":"core","slug":"tmux-session-ref"},{"id":"tmux.Window.Ref","name":"Ref","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"Ref"}],"doc":{"summary":"Ref returns a [Ref] addressing the receiver."},"source":{"file":"tmux/plan.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Ref","product":"core","slug":"tmux-window-ref"},{"id":"tmux.Pane.Ref","name":"Ref","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"Ref"}],"doc":{"summary":"Ref returns a [Ref] addressing the receiver."},"source":{"file":"tmux/plan.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Ref","product":"core","slug":"tmux-pane-ref"},{"id":"tmux.SessionRef","name":"SessionRef","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"id","type":"SessionID"}],"returns":"Ref"}],"doc":{"summary":"SessionRef returns a selector-relative [Ref] addressing a session by ID, for a caller holding an identifier rather than a materialized record."},"source":{"file":"tmux/plan.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SessionRef","product":"core","slug":"tmux-sessionref"},{"id":"tmux.WindowRef","name":"WindowRef","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"id","type":"WindowID"}],"returns":"Ref"}],"doc":{"summary":"WindowRef returns a selector-relative [Ref] addressing a window by ID, for a caller holding an identifier rather than a materialized record."},"source":{"file":"tmux/plan.go","line":73,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowRef","product":"core","slug":"tmux-windowref"},{"id":"tmux.PaneRef","name":"PaneRef","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"id","type":"PaneID"}],"returns":"Ref"}],"doc":{"summary":"PaneRef returns a selector-relative [Ref] addressing a pane by ID, for a caller holding an identifier rather than a materialized record."},"source":{"file":"tmux/plan.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneRef","product":"core","slug":"tmux-paneref"},{"id":"tmux.Ref.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Ref","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the target a Ref resolves to, or a placeholder naming the step that will produce it."},"source":{"file":"tmux/plan.go","line":81,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Ref.String","product":"core","slug":"tmux-ref-string"},{"id":"tmux.Op","name":"Op","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Op is one tmux command a [Plan] has recorded but not run. Build one with a [Plan] method rather than directly; the zero value records nothing."},"source":{"file":"tmux/plan.go","line":93,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Op","product":"core","slug":"tmux-op"},{"id":"tmux.Op.Chainable","name":"Chainable","kind":"method","modifiers":[],"parent":"tmux.Op","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Chainable reports whether the operation may share a tmux invocation with others, which is what a [Planner] groups on."},"source":{"file":"tmux/plan.go","line":110,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Op.Chainable","product":"core","slug":"tmux-op-chainable"},{"id":"tmux.Op.Command","name":"Command","kind":"method","modifiers":[],"parent":"tmux.Op","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Command returns the tmux command the operation records."},"source":{"file":"tmux/plan.go","line":113,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Op.Command","product":"core","slug":"tmux-op-command"},{"id":"tmux.Plan","name":"Plan","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Plan records ordered tmux commands for later execution. It groups commands that need no answer and lets later steps reference objects earlier steps create.","body":"Recording touches nothing. [Plan.Preview] renders what would be sent and\n[Plan.Explain] says how it would be grouped, both without a server;\n[Plan.Run] is the only method that reaches tmux.\n\nA Plan is not safe for concurrent use."},"source":{"file":"tmux/plan.go","line":126,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan","product":"core","slug":"tmux-plan"},{"id":"tmux.NewPlan","name":"NewPlan","kind":"function","modifiers":[],"signatures":[{"params":[],"returns":"*Plan"}],"doc":{"summary":"NewPlan returns an empty [Plan]."},"source":{"file":"tmux/plan.go","line":139,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewPlan","product":"core","slug":"tmux-newplan"},{"id":"tmux.Plan.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns how many operations the plan has recorded."},"source":{"file":"tmux/plan.go","line":151,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.Len","product":"core","slug":"tmux-plan-len"},{"id":"tmux.Plan.Ops","name":"Ops","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[],"returns":"[]Op"}],"doc":{"summary":"Ops returns the recorded operations, in order, for a [Planner] to group."},"source":{"file":"tmux/plan.go","line":154,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.Ops","product":"core","slug":"tmux-plan-ops"},{"id":"tmux.Dispatch","name":"Dispatch","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Dispatch is one tmux invocation and the operations it carries. A dispatch holding more than one operation is sent as a tmux command list."},"source":{"file":"tmux/plan.go","line":245,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Dispatch","product":"core","slug":"tmux-dispatch"},{"id":"tmux.Dispatch.Ops","name":"Ops","kind":"attribute","modifiers":[],"parent":"tmux.Dispatch","signatures":[],"type":"[]int","doc":{"summary":"Ops are the indices of the operations this dispatch carries, in order."},"source":{"file":"tmux/plan.go","line":247,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Dispatch.Ops","product":"core","slug":"tmux-dispatch-ops"},{"id":"tmux.Dispatch.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.Dispatch","signatures":[],"type":"string","doc":{"summary":"Reason says why the dispatch ends where it does. It is \"chained\" for a command list, \"creates\" for an operation whose new object's ID a later step needs, \"captures\" for one whose output the caller reads, and \"alone\" for a chainable operation with nothing beside it to chain to."},"source":{"file":"tmux/plan.go","line":252,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Dispatch.Reason","product":"core","slug":"tmux-dispatch-reason"},{"id":"tmux.Planner","name":"Planner","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Planner groups a plan's operations into tmux invocations.","body":"Dispatches must contain every operation exactly once and in recorded order.\n[Plan.Run] validates this before reaching tmux.\n\nOperations with [Op.Chainable] false must run alone because command-list\nstdout cannot be attributed to an individual operation."},"source":{"file":"tmux/plan.go","line":262,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Planner","product":"core","slug":"tmux-planner"},{"id":"tmux.Sequential","name":"Sequential","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Sequential sends every operation as its own tmux invocation. It is the simplest correct planner, and useful as a baseline: a plan produces the same results through it as through [Folding], at one invocation per operation."},"source":{"file":"tmux/plan.go","line":270,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Sequential","product":"core","slug":"tmux-sequential"},{"id":"tmux.Sequential.Plan","name":"Plan","kind":"method","modifiers":[],"parent":"tmux.Sequential","signatures":[{"params":[{"name":"ops","type":"[]Op"}],"returns":"[]Dispatch"}],"doc":{"summary":"Plan returns one dispatch per operation."},"source":{"file":"tmux/plan.go","line":273,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Sequential.Plan","product":"core","slug":"tmux-sequential-plan"},{"id":"tmux.Folding","name":"Folding","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Folding groups each run of operations that neither answer nor create into one tmux command list, and sends the rest alone. It is what [Plan.Run] uses."},"source":{"file":"tmux/plan.go","line":290,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Folding","product":"core","slug":"tmux-folding"},{"id":"tmux.Folding.Plan","name":"Plan","kind":"method","modifiers":[],"parent":"tmux.Folding","signatures":[{"params":[{"name":"ops","type":"[]Op"}],"returns":"[]Dispatch"}],"doc":{"summary":"Plan returns the dispatches for ops, grouping consecutive chainable runs."},"source":{"file":"tmux/plan.go","line":293,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Folding.Plan","product":"core","slug":"tmux-folding-plan"},{"id":"tmux.Plan.Explain","name":"Explain","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[],"returns":"[]Dispatch"}],"doc":{"summary":"Explain reports how [Plan.Run] would group the recorded operations into tmux commands, and why each group ends where it does. It runs no commands.","body":"The number of dispatches is the number of tmux invocations."},"source":{"file":"tmux/plan.go","line":330,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.Explain","product":"core","slug":"tmux-plan-explain"},{"id":"tmux.Plan.ExplainWith","name":"ExplainWith","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"planner","type":"Planner"}],"returns":"[]Dispatch"}],"doc":{"summary":"ExplainWith reports how planner would group the recorded operations."},"source":{"file":"tmux/plan.go","line":333,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.ExplainWith","product":"core","slug":"tmux-plan-explainwith"},{"id":"tmux.Plan.Preview","name":"Preview","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"version","type":"Version"}],"returns":"([][]string, error)"}],"doc":{"summary":"Preview renders every recorded operation's argument vector without running anything, for the tmux version given.","body":"An entry is nil when it references an object an earlier step has not created.\n\nOther render failures return the entries completed before the error. Preview\ncatches them before a non-atomic run can partially mutate tmux."},"source":{"file":"tmux/plan.go","line":344,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.Preview","product":"core","slug":"tmux-plan-preview"},{"id":"tmux.PlanResult","name":"PlanResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PlanResult reports what running a [Plan] did, one entry per recorded operation, in the order they were recorded."},"source":{"file":"tmux/plan.go","line":370,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanResult","product":"core","slug":"tmux-planresult"},{"id":"tmux.PlanResult.Ops","name":"Ops","kind":"attribute","modifiers":[],"parent":"tmux.PlanResult","signatures":[],"type":"[]OpResult","doc":{"summary":"Ops holds one result per recorded operation, in the order recorded."},"source":{"file":"tmux/plan.go","line":372,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanResult.Ops","product":"core","slug":"tmux-planresult-ops"},{"id":"tmux.PlanResult.OK","name":"OK","kind":"method","modifiers":[],"parent":"tmux.PlanResult","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"OK reports whether every operation completed."},"source":{"file":"tmux/plan.go","line":376,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanResult.OK","product":"core","slug":"tmux-planresult-ok"},{"id":"tmux.PlanResult.Err","name":"Err","kind":"method","modifiers":[],"parent":"tmux.PlanResult","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Err returns the first failed or indeterminate operation's error, or nil when every operation completed."},"source":{"file":"tmux/plan.go","line":387,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PlanResult.Err","product":"core","slug":"tmux-planresult-err"},{"id":"tmux.OpStatus","name":"OpStatus","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OpStatus reports what became of one operation in a plan."},"source":{"file":"tmux/plan.go","line":397,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpStatus","product":"core","slug":"tmux-opstatus"},{"id":"tmux.OpComplete","name":"OpComplete","kind":"constant","modifiers":[],"signatures":[],"type":"OpStatus","doc":{"summary":"OpComplete is an operation tmux ran successfully."},"source":{"file":"tmux/plan.go","line":401,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpComplete","product":"core","slug":"tmux-opcomplete"},{"id":"tmux.OpFailed","name":"OpFailed","kind":"constant","modifiers":[],"signatures":[],"type":"OpStatus","doc":{"summary":"OpFailed is an operation tmux refused. Only an operation sent alone can receive this status."},"source":{"file":"tmux/plan.go","line":404,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpFailed","product":"core","slug":"tmux-opfailed"},{"id":"tmux.OpIndeterminate","name":"OpIndeterminate","kind":"constant","modifiers":[],"signatures":[],"type":"OpStatus","doc":{"summary":"OpIndeterminate is an operation dispatched without enough reply evidence to prove whether tmux applied or rejected it."},"source":{"file":"tmux/plan.go","line":407,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpIndeterminate","product":"core","slug":"tmux-opindeterminate"},{"id":"tmux.OpSkipped","name":"OpSkipped","kind":"constant","modifiers":[],"signatures":[],"type":"OpStatus","doc":{"summary":"OpSkipped is an operation the plan did not dispatch because an earlier dispatch failed or became indeterminate."},"source":{"file":"tmux/plan.go","line":410,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpSkipped","product":"core","slug":"tmux-opskipped"},{"id":"tmux.OpStatus.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.OpStatus","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer."},"source":{"file":"tmux/plan.go","line":414,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpStatus.String","product":"core","slug":"tmux-opstatus-string"},{"id":"tmux.OpResult","name":"OpResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OpResult is what one operation in a [Plan] produced."},"source":{"file":"tmux/plan.go","line":430,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpResult","product":"core","slug":"tmux-opresult"},{"id":"tmux.OpResult.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"string","doc":{"summary":"Command is the tmux command the operation recorded."},"source":{"file":"tmux/plan.go","line":432,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpResult.Command","product":"core","slug":"tmux-opresult-command"},{"id":"tmux.OpResult.Status","name":"Status","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"OpStatus","doc":{"summary":"Status reports what became of the operation."},"source":{"file":"tmux/plan.go","line":434,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpResult.Status","product":"core","slug":"tmux-opresult-status"},{"id":"tmux.OpResult.Created","name":"Created","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"string","doc":{"summary":"Created is the ID tmux reported for an object this operation brought into being, and is empty for every other operation."},"source":{"file":"tmux/plan.go","line":437,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpResult.Created","product":"core","slug":"tmux-opresult-created"},{"id":"tmux.OpResult.Stdout","name":"Stdout","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"[]string","doc":{"summary":"Stdout holds the operation's output, for an operation that captures it."},"source":{"file":"tmux/plan.go","line":439,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpResult.Stdout","product":"core","slug":"tmux-opresult-stdout"},{"id":"tmux.OpResult.Err","name":"Err","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"error","doc":{"summary":"Err is the failure or uncertainty for a failed or indeterminate operation."},"source":{"file":"tmux/plan.go","line":441,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.OpResult.Err","product":"core","slug":"tmux-opresult-err"},{"id":"tmux.Plan.Run","name":"Run","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"server","type":"Server"}],"returns":"(PlanResult, error)"}],"doc":{"summary":"Run sends the recorded operations through server and returns one result per step.","body":"Operations that need no answer travel together in one tmux command list;\n[Plan.Explain] reports the grouping. Run stops at the first failed or\nindeterminate dispatch; later operations are [OpSkipped].\n\nTmux refusals appear in results. Transport, context, and [PlanError] failures\nare returned. Run is not atomic; completed mutations remain after failure."},"source":{"file":"tmux/plan.go","line":452,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.Run","product":"core","slug":"tmux-plan-run"},{"id":"tmux.Plan.RunWith","name":"RunWith","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"server","type":"Server"},{"name":"planner","type":"Planner"}],"returns":"(PlanResult, error)"}],"doc":{"summary":"RunWith runs the plan with planner deciding dispatch grouping. Successful execution produces planner-independent results, but every operation in a failed grouped dispatch is [OpIndeterminate]. Use [Sequential] for exact attribution."},"source":{"file":"tmux/plan.go","line":460,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.RunWith","product":"core","slug":"tmux-plan-runwith"},{"id":"tmux.Plan.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"args","type":"string"}]}],"doc":{"summary":"Cmd records raw tmux arguments targeted at target.","body":"It can target an object an earlier step creates. A zero [Ref] records an\nuntargeted server command.\n\nThe recorded command is assumed to neither print output the caller reads nor\ncreate an object, which is what lets it share a dispatch with its neighbours.\nUse [Plan.CmdCapture] for one whose output is the point."},"source":{"file":"tmux/plan.go","line":700,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.Cmd","product":"core","slug":"tmux-plan-cmd"},{"id":"tmux.Plan.CmdCapture","name":"CmdCapture","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"args","type":"string"}]}],"doc":{"summary":"CmdCapture records raw tmux arguments whose output is returned in the step's [OpResult], and is otherwise [Plan.Cmd].","body":"Reading output is what stops an operation sharing a dispatch, so this is sent\non its own; [Plan.Explain] reports that."},"source":{"file":"tmux/plan.go","line":709,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.CmdCapture","product":"core","slug":"tmux-plan-cmdcapture"},{"id":"tmux.Plan.SplitPane","name":"SplitPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"SplitPaneRequest"}],"returns":"Ref"}],"doc":{"summary":"SplitPane records a split of the window or pane target names, and returns a [Ref] to the pane it will create.","body":"The returned ref can target later steps before the pane exists:\n\nplan := tmux.NewPlan()\npane := plan.SplitPane(window.Ref(), tmux.SplitPaneRequest{})\nplan.SendKeys(pane, tmux.SendKeysRequest{Command: tmux.Ptr(\"top\")})\nresult, err := plan.Run(ctx, server)"},"source":{"file":"tmux/plan_pane.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SplitPane","product":"core","slug":"tmux-plan-splitpane"},{"id":"tmux.Plan.SendKeys","name":"SendKeys","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"SendKeysRequest"}]}],"doc":{"summary":"SendKeys records keys sent to the pane target names.","body":"Sending keys produces no output and can share a dispatch; see [Plan.Explain].\n\nA request carrying a command records two steps, as [Pane.SendKeys] issues two\ntmux commands: the keys, and the Enter that submits them. Both are chainable,\nso they still travel together."},"source":{"file":"tmux/plan_pane.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SendKeys","product":"core","slug":"tmux-plan-sendkeys"},{"id":"tmux.Plan.DisplayMessage","name":"DisplayMessage","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"format","type":"string"}]}],"doc":{"summary":"DisplayMessage records a format expanded against the object target names, and returns its output in the step's [OpResult]. The zero [Ref] expands it against no object, the way [Plan.Cmd] takes one.","body":"It runs alone because command-list stdout has no operation boundaries."},"source":{"file":"tmux/plan_pane.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.DisplayMessage","product":"core","slug":"tmux-plan-displaymessage"},{"id":"tmux.Plan.KillPane","name":"KillPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillPane records the destruction of the pane target names."},"source":{"file":"tmux/plan_pane.go","line":85,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.KillPane","product":"core","slug":"tmux-plan-killpane"},{"id":"tmux.Plan.KillOtherPanes","name":"KillOtherPanes","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillOtherPanes records the destruction of every pane in the window holding the pane target names, except that pane."},"source":{"file":"tmux/plan_pane.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.KillOtherPanes","product":"core","slug":"tmux-plan-killotherpanes"},{"id":"tmux.Plan.SelectPane","name":"SelectPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"PaneSelectRequest"}]}],"doc":{"summary":"SelectPane records a selection or marking of the pane target names."},"source":{"file":"tmux/plan_pane.go","line":108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SelectPane","product":"core","slug":"tmux-plan-selectpane"},{"id":"tmux.Plan.ResizePane","name":"ResizePane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"ResizePaneRequest"}]}],"doc":{"summary":"ResizePane records a resize of the pane target names."},"source":{"file":"tmux/plan_pane.go","line":119,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.ResizePane","product":"core","slug":"tmux-plan-resizepane"},{"id":"tmux.Plan.SetPaneTitle","name":"SetPaneTitle","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"title","type":"string"}]}],"doc":{"summary":"SetPaneTitle records a title for the pane target names."},"source":{"file":"tmux/plan_pane.go","line":130,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SetPaneTitle","product":"core","slug":"tmux-plan-setpanetitle"},{"id":"tmux.Plan.ClearHistory","name":"ClearHistory","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"ClearHistoryRequest"}]}],"doc":{"summary":"ClearHistory records the clearing of the scrollback of the pane target names."},"source":{"file":"tmux/plan_pane.go","line":141,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.ClearHistory","product":"core","slug":"tmux-plan-clearhistory"},{"id":"tmux.Plan.SendPrefix","name":"SendPrefix","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"key","type":"PrefixKey"}]}],"doc":{"summary":"SendPrefix records tmux's prefix key sent to the pane target names."},"source":{"file":"tmux/plan_pane.go","line":154,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SendPrefix","product":"core","slug":"tmux-plan-sendprefix"},{"id":"tmux.Plan.PipePane","name":"PipePane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"PipePaneRequest"}]}],"doc":{"summary":"PipePane records the pane target names having its output piped to a shell command."},"source":{"file":"tmux/plan_pane.go","line":166,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.PipePane","product":"core","slug":"tmux-plan-pipepane"},{"id":"tmux.Plan.RespawnPane","name":"RespawnPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"RespawnRequest"}]}],"doc":{"summary":"RespawnPane records the pane target names being restarted with a new command."},"source":{"file":"tmux/plan_pane.go","line":177,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.RespawnPane","product":"core","slug":"tmux-plan-respawnpane"},{"id":"tmux.Plan.SwapPane","name":"SwapPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"detach","type":"bool"}]}],"doc":{"summary":"SwapPane records the panes target and source name exchanging places.","body":"Both panes are Refs so either may be created by an earlier step. Detach leaves\nactive selection alone; KeepZoom preserves a zoomed window."},"source":{"file":"tmux/plan_pane.go","line":191,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SwapPane","product":"core","slug":"tmux-plan-swappane"},{"id":"tmux.Plan.JoinPane","name":"JoinPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"horizontal","type":"bool"}]}],"doc":{"summary":"JoinPane records the pane source names being moved beside the pane target names, splitting that pane's space.","body":"Horizontal splits left and right; Detach leaves active selection alone."},"source":{"file":"tmux/plan_pane.go","line":216,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.JoinPane","product":"core","slug":"tmux-plan-joinpane"},{"id":"tmux.Plan.MovePane","name":"MovePane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"horizontal","type":"bool"}]}],"doc":{"summary":"MovePane records the pane source names being moved beside the pane target names without joining it to that pane's layout."},"source":{"file":"tmux/plan_pane.go","line":229,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.MovePane","product":"core","slug":"tmux-plan-movepane"},{"id":"tmux.Plan.StartServer","name":"StartServer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[]}],"doc":{"summary":"StartServer records the tmux server being started if it is not running."},"source":{"file":"tmux/plan_server.go","line":8,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.StartServer","product":"core","slug":"tmux-plan-startserver"},{"id":"tmux.Plan.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"SetPlanOptionRequest"}]}],"doc":{"summary":"SetOption records a tmux option written on the object target names, or on the server when target is the zero [Ref] and Global is set.","body":"It takes the option's tmux name because typed accessors read values back."},"source":{"file":"tmux/plan_server.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SetOption","product":"core","slug":"tmux-plan-setoption"},{"id":"tmux.SetPlanOptionRequest","name":"SetPlanOptionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetPlanOptionRequest names one tmux option write for [Plan.SetOption]. Its zero value is invalid, because Name is required."},"source":{"file":"tmux/plan_server.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetPlanOptionRequest","product":"core","slug":"tmux-setplanoptionrequest"},{"id":"tmux.SetPlanOptionRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"string","doc":{"summary":"Name is the tmux option name, such as \"status\" or a user option \"@thing\"."},"source":{"file":"tmux/plan_server.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetPlanOptionRequest.Name","product":"core","slug":"tmux-setplanoptionrequest-name"},{"id":"tmux.SetPlanOptionRequest.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"string","doc":{"summary":"Value is the value to write. It is omitted when Unset is set."},"source":{"file":"tmux/plan_server.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetPlanOptionRequest.Value","product":"core","slug":"tmux-setplanoptionrequest-value"},{"id":"tmux.SetPlanOptionRequest.Global","name":"Global","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Global writes the server or global scope rather than the target's own."},"source":{"file":"tmux/plan_server.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetPlanOptionRequest.Global","product":"core","slug":"tmux-setplanoptionrequest-global"},{"id":"tmux.SetPlanOptionRequest.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Window writes a window option rather than a session or server one."},"source":{"file":"tmux/plan_server.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetPlanOptionRequest.Window","product":"core","slug":"tmux-setplanoptionrequest-window"},{"id":"tmux.SetPlanOptionRequest.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Pane writes a pane option."},"source":{"file":"tmux/plan_server.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetPlanOptionRequest.Pane","product":"core","slug":"tmux-setplanoptionrequest-pane"},{"id":"tmux.SetPlanOptionRequest.Unset","name":"Unset","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Unset removes the option instead of writing it."},"source":{"file":"tmux/plan_server.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetPlanOptionRequest.Unset","product":"core","slug":"tmux-setplanoptionrequest-unset"},{"id":"tmux.SetPlanOptionRequest.Append","name":"Append","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Append adds to an existing value rather than replacing it."},"source":{"file":"tmux/plan_server.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetPlanOptionRequest.Append","product":"core","slug":"tmux-setplanoptionrequest-append"},{"id":"tmux.Plan.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"},{"name":"global","type":"bool"}]}],"doc":{"summary":"SetHook records a tmux hook written on the object target names."},"source":{"file":"tmux/plan_server.go","line":96,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SetHook","product":"core","slug":"tmux-plan-sethook"},{"id":"tmux.Plan.SetBuffer","name":"SetBuffer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"name","type":"string"}]}],"doc":{"summary":"SetBuffer records text stored in a tmux buffer."},"source":{"file":"tmux/plan_server.go","line":119,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SetBuffer","product":"core","slug":"tmux-plan-setbuffer"},{"id":"tmux.Plan.DeleteBuffer","name":"DeleteBuffer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"name","type":"string"}]}],"doc":{"summary":"DeleteBuffer records a tmux buffer being removed. An empty name removes the most recently added buffer."},"source":{"file":"tmux/plan_server.go","line":134,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.DeleteBuffer","product":"core","slug":"tmux-plan-deletebuffer"},{"id":"tmux.Plan.DetachClient","name":"DetachClient","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"client","type":"ClientName"}]}],"doc":{"summary":"DetachClient records one client being detached. A client is named directly because plans do not create clients."},"source":{"file":"tmux/plan_server.go","line":149,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.DetachClient","product":"core","slug":"tmux-plan-detachclient"},{"id":"tmux.Plan.SuspendClient","name":"SuspendClient","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"client","type":"ClientName"}]}],"doc":{"summary":"SuspendClient records one client being suspended."},"source":{"file":"tmux/plan_server.go","line":160,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SuspendClient","product":"core","slug":"tmux-plan-suspendclient"},{"id":"tmux.Plan.RefreshClient","name":"RefreshClient","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"client","type":"ClientName"}]}],"doc":{"summary":"RefreshClient records one client being asked to redraw."},"source":{"file":"tmux/plan_server.go","line":171,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.RefreshClient","product":"core","slug":"tmux-plan-refreshclient"},{"id":"tmux.Plan.SwitchClient","name":"SwitchClient","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"client","type":"ClientName"}]}],"doc":{"summary":"SwitchClient records one client being moved to the session target names. target may refer to a session an earlier step creates."},"source":{"file":"tmux/plan_server.go","line":183,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SwitchClient","product":"core","slug":"tmux-plan-switchclient"},{"id":"tmux.Plan.LockServer","name":"LockServer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[]}],"doc":{"summary":"LockServer records every client attached to the server being locked."},"source":{"file":"tmux/plan_server.go","line":194,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.LockServer","product":"core","slug":"tmux-plan-lockserver"},{"id":"tmux.Plan.NewSession","name":"NewSession","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"request","type":"NewSessionRequest"}],"returns":"Ref"}],"doc":{"summary":"NewSession records a detached session and returns a [Ref] to it.","body":"KillExisting is rejected: [Server.NewSession] probes for the named session\nand removes it before creating, and a plan records without reading. Record\n[Plan.KillSession] before this instead, which says the same thing in the\norder it happens."},"source":{"file":"tmux/plan_session.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.NewSession","product":"core","slug":"tmux-plan-newsession"},{"id":"tmux.Plan.KillSession","name":"KillSession","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillSession records the destruction of the session target names."},"source":{"file":"tmux/plan_session.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.KillSession","product":"core","slug":"tmux-plan-killsession"},{"id":"tmux.Plan.RenameSession","name":"RenameSession","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"}]}],"doc":{"summary":"RenameSession records a new name for the session target names."},"source":{"file":"tmux/plan_session.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.RenameSession","product":"core","slug":"tmux-plan-renamesession"},{"id":"tmux.Plan.NextWindow","name":"NextWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"NextWindow records the session target names moving to its next window."},"source":{"file":"tmux/plan_session.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.NextWindow","product":"core","slug":"tmux-plan-nextwindow"},{"id":"tmux.Plan.PreviousWindow","name":"PreviousWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"PreviousWindow records the session target names moving to its previous window."},"source":{"file":"tmux/plan_session.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.PreviousWindow","product":"core","slug":"tmux-plan-previouswindow"},{"id":"tmux.Plan.LastWindow","name":"LastWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"LastWindow records the session target names returning to its previously current window."},"source":{"file":"tmux/plan_session.go","line":81,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.LastWindow","product":"core","slug":"tmux-plan-lastwindow"},{"id":"tmux.Plan.LockSession","name":"LockSession","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"LockSession records every client attached to the session target names being locked."},"source":{"file":"tmux/plan_session.go","line":93,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.LockSession","product":"core","slug":"tmux-plan-locksession"},{"id":"tmux.Plan.DetachClients","name":"DetachClients","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"DetachClients records every client attached to the session target names being detached."},"source":{"file":"tmux/plan_session.go","line":105,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.DetachClients","product":"core","slug":"tmux-plan-detachclients"},{"id":"tmux.Plan.SetEnvironment","name":"SetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"}]}],"doc":{"summary":"SetEnvironment records a variable set in the session target names, or in the server when target is the zero [Ref]."},"source":{"file":"tmux/plan_session.go","line":120,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SetEnvironment","product":"core","slug":"tmux-plan-setenvironment"},{"id":"tmux.Plan.UnsetEnvironment","name":"UnsetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"}]}],"doc":{"summary":"UnsetEnvironment records a variable removed from the session target names, or from the server when target is the zero [Ref]."},"source":{"file":"tmux/plan_session.go","line":138,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.UnsetEnvironment","product":"core","slug":"tmux-plan-unsetenvironment"},{"id":"tmux.Plan.SourceFile","name":"SourceFile","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"request","type":"SourceFileRequest"}]}],"doc":{"summary":"SourceFile records a tmux configuration file being loaded."},"source":{"file":"tmux/plan_session.go","line":152,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SourceFile","product":"core","slug":"tmux-plan-sourcefile"},{"id":"tmux.Plan.KillServer","name":"KillServer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[]}],"doc":{"summary":"KillServer records the tmux server being shut down. Nothing recorded after it can run because the server will be gone."},"source":{"file":"tmux/plan_session.go","line":164,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.KillServer","product":"core","slug":"tmux-plan-killserver"},{"id":"tmux.Plan.NewWindow","name":"NewWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"NewWindowRequest"}],"returns":"Ref"}],"doc":{"summary":"NewWindow records a window created in the session or beside the window that target names, and returns a [Ref] to it.","body":"SelectExisting is rejected: it asks tmux for an existing window's\nexpanded name before creating anything, and a plan records without reading."},"source":{"file":"tmux/plan_window.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.NewWindow","product":"core","slug":"tmux-plan-newwindow"},{"id":"tmux.Plan.KillWindow","name":"KillWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillWindow records the destruction of the window target names."},"source":{"file":"tmux/plan_window.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.KillWindow","product":"core","slug":"tmux-plan-killwindow"},{"id":"tmux.Plan.KillOtherWindows","name":"KillOtherWindows","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillOtherWindows records the destruction of every window in the session holding the window target names, except that window."},"source":{"file":"tmux/plan_window.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.KillOtherWindows","product":"core","slug":"tmux-plan-killotherwindows"},{"id":"tmux.Plan.RenameWindow","name":"RenameWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"}]}],"doc":{"summary":"RenameWindow records a new name for the window target names."},"source":{"file":"tmux/plan_window.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.RenameWindow","product":"core","slug":"tmux-plan-renamewindow"},{"id":"tmux.Plan.SelectWindow","name":"SelectWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"SelectWindow records the window target names becoming its session's current window."},"source":{"file":"tmux/plan_window.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SelectWindow","product":"core","slug":"tmux-plan-selectwindow"},{"id":"tmux.Plan.SelectLayout","name":"SelectLayout","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"SelectLayoutRequest"}]}],"doc":{"summary":"SelectLayout records a layout applied to the window target names."},"source":{"file":"tmux/plan_window.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SelectLayout","product":"core","slug":"tmux-plan-selectlayout"},{"id":"tmux.Plan.NextLayout","name":"NextLayout","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"NextLayout records the next preset layout applied to the window target names."},"source":{"file":"tmux/plan_window.go","line":93,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.NextLayout","product":"core","slug":"tmux-plan-nextlayout"},{"id":"tmux.Plan.PreviousLayout","name":"PreviousLayout","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"PreviousLayout records the previous preset layout applied to the window target names."},"source":{"file":"tmux/plan_window.go","line":105,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.PreviousLayout","product":"core","slug":"tmux-plan-previouslayout"},{"id":"tmux.Plan.ResizeWindow","name":"ResizeWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"ResizeWindowRequest"}]}],"doc":{"summary":"ResizeWindow records a resize of the window target names."},"source":{"file":"tmux/plan_window.go","line":116,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.ResizeWindow","product":"core","slug":"tmux-plan-resizewindow"},{"id":"tmux.Plan.RotateWindow","name":"RotateWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"RotateWindowRequest"}]}],"doc":{"summary":"RotateWindow records the panes of the window target names being rotated through their positions."},"source":{"file":"tmux/plan_window.go","line":128,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.RotateWindow","product":"core","slug":"tmux-plan-rotatewindow"},{"id":"tmux.Plan.RespawnWindow","name":"RespawnWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"RespawnRequest"}]}],"doc":{"summary":"RespawnWindow records the window target names being restarted with a new command."},"source":{"file":"tmux/plan_window.go","line":140,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.RespawnWindow","product":"core","slug":"tmux-plan-respawnwindow"},{"id":"tmux.Plan.LastPane","name":"LastPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"LastPane records the window target names returning to its previously active pane."},"source":{"file":"tmux/plan_window.go","line":152,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.LastPane","product":"core","slug":"tmux-plan-lastpane"},{"id":"tmux.Plan.LinkWindow","name":"LinkWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"LinkWindowRequest"}]}],"doc":{"summary":"LinkWindow records the window source names being linked into the session target names.","body":"target supplies the destination session so it may refer to a session an\nearlier step creates. TargetIndex still selects the position within it."},"source":{"file":"tmux/plan_window.go","line":167,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.LinkWindow","product":"core","slug":"tmux-plan-linkwindow"},{"id":"tmux.Plan.UnlinkWindow","name":"UnlinkWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"UnlinkWindowRequest"}]}],"doc":{"summary":"UnlinkWindow records the window target names being removed from the session it is linked into."},"source":{"file":"tmux/plan_window.go","line":180,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.UnlinkWindow","product":"core","slug":"tmux-plan-unlinkwindow"},{"id":"tmux.Plan.MoveWindow","name":"MoveWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"MoveWindowRequest"}]}],"doc":{"summary":"MoveWindow records the window source names being moved into the session target names.","body":"target supplies the destination session. TargetIndex selects its position."},"source":{"file":"tmux/plan_window.go","line":198,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.MoveWindow","product":"core","slug":"tmux-plan-movewindow"},{"id":"tmux.Plan.SwapWindow","name":"SwapWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"detach","type":"bool"}]}],"doc":{"summary":"SwapWindow records the windows target and source name exchanging places. Detach leaves each session's current window unchanged."},"source":{"file":"tmux/plan_window.go","line":211,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Plan.SwapWindow","product":"core","slug":"tmux-plan-swapwindow"},{"id":"tmux.ErrPollCondition","name":"ErrPollCondition","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrPollCondition identifies a poll whose condition was nil. It is matched by errors.Is."},"source":{"file":"tmux/poll.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrPollCondition","product":"core","slug":"tmux-errpollcondition"},{"id":"tmux.Poll","name":"Poll","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"interval","type":"time.Duration"},{"name":"condition","type":"func(context.Context) (bool, error)"}],"returns":"error"}],"doc":{"summary":"Poll checks condition immediately and then after each interval, until it reports true, returns an error, or ctx ends.","body":"A condition receives ctx and must observe cancellation itself; Poll cannot\ninterrupt one already running. Poll returns condition errors unchanged and\nctx.Err when ctx ends first.\n\nPoll is for a state tmux does not announce. Waiting for a pane to print\nsomething is not one: [PaneObservation.WaitFor] is woken by tmux as the\npane writes, where a poll re-reads the screen on a guess and can match a\nshell's echo of what was typed. [Server.WaitFor] waits on tmux's separate\nwait-for channel."},"source":{"file":"tmux/poll.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Poll","product":"core","slug":"tmux-poll"},{"id":"tmux.PromptType","name":"PromptType","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PromptType selects one closed tmux prompt-history class. The zero value selects all prompt types."},"source":{"file":"tmux/prompt_history.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptType","product":"core","slug":"tmux-prompttype"},{"id":"tmux.PromptTypeAll","name":"PromptTypeAll","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeAll selects every prompt-history class and omits -T."},"source":{"file":"tmux/prompt_history.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptTypeAll","product":"core","slug":"tmux-prompttypeall"},{"id":"tmux.PromptTypeCommand","name":"PromptTypeCommand","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeCommand selects command-prompt history."},"source":{"file":"tmux/prompt_history.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptTypeCommand","product":"core","slug":"tmux-prompttypecommand"},{"id":"tmux.PromptTypeSearch","name":"PromptTypeSearch","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeSearch selects search-prompt history."},"source":{"file":"tmux/prompt_history.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptTypeSearch","product":"core","slug":"tmux-prompttypesearch"},{"id":"tmux.PromptTypeTarget","name":"PromptTypeTarget","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeTarget selects target-prompt history."},"source":{"file":"tmux/prompt_history.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptTypeTarget","product":"core","slug":"tmux-prompttypetarget"},{"id":"tmux.PromptTypeWindowTarget","name":"PromptTypeWindowTarget","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeWindowTarget selects window-target-prompt history."},"source":{"file":"tmux/prompt_history.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptTypeWindowTarget","product":"core","slug":"tmux-prompttypewindowtarget"},{"id":"tmux.PromptHistoryRequest","name":"PromptHistoryRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PromptHistoryRequest selects one prompt-history class. A zero request selects every class."},"source":{"file":"tmux/prompt_history.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptHistoryRequest","product":"core","slug":"tmux-prompthistoryrequest"},{"id":"tmux.PromptHistoryRequest.Type","name":"Type","kind":"attribute","modifiers":[],"parent":"tmux.PromptHistoryRequest","signatures":[],"type":"PromptType","doc":{"summary":"Type selects a prompt-history class; zero selects all classes."},"source":{"file":"tmux/prompt_history.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PromptHistoryRequest.Type","product":"core","slug":"tmux-prompthistoryrequest-type"},{"id":"tmux.Server.ShowPromptHistory","name":"ShowPromptHistory","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PromptHistoryRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ShowPromptHistory returns an owned snapshot of tmux prompt-history lines. It requires tmux 3.3 or later and returns [VersionTooLowError] below that floor. A tmux command or transport failure is returned rather than answered with no history."},"source":{"file":"tmux/prompt_history.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ShowPromptHistory","product":"core","slug":"tmux-server-showprompthistory"},{"id":"tmux.Server.ClearPromptHistory","name":"ClearPromptHistory","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PromptHistoryRequest"}],"returns":"error"}],"doc":{"summary":"ClearPromptHistory clears all tmux prompt history or one selected class. Version, transport, and completed-stderr failures are returned. It requires tmux 3.3 or later and returns [VersionTooLowError] below that floor."},"source":{"file":"tmux/prompt_history.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ClearPromptHistory","product":"core","slug":"tmux-server-clearprompthistory"},{"id":"tmux.Session.ActiveWindow","name":"ActiveWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(Window, bool)"}],"doc":{"summary":"ActiveWindow returns this session's sole active winlink from the materialized snapshot. It never queries tmux; use [Session.ResolveActiveWindow] for live state."},"source":{"file":"tmux/relations.go","line":11,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ActiveWindow","product":"core","slug":"tmux-session-activewindow"},{"id":"tmux.Session.ActivePane","name":"ActivePane","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(Pane, bool)"}],"doc":{"summary":"ActivePane returns the active pane in this session's materialized active window. It never queries tmux; use [Session.ResolveActivePane] for live state."},"source":{"file":"tmux/relations.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ActivePane","product":"core","slug":"tmux-session-activepane"},{"id":"tmux.Window.ActivePane","name":"ActivePane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(Pane, bool)"}],"doc":{"summary":"ActivePane returns the first active pane in this materialized winlink view. It never queries tmux; use [Window.ResolveActivePane] for live state."},"source":{"file":"tmux/relations.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ActivePane","product":"core","slug":"tmux-window-activepane"},{"id":"tmux.Window.LinkedSessions","name":"LinkedSessions","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"([]Session, bool)"}],"doc":{"summary":"LinkedSessions returns newly allocated shallow copies of materialized sessions containing this window, and reports whether the receiver carries relations at all. It never queries tmux."},"source":{"file":"tmux/relations.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.LinkedSessions","product":"core","slug":"tmux-window-linkedsessions"},{"id":"tmux.Session.ResolveActiveWindow","name":"ResolveActiveWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"ResolveActiveWindow snapshots live tmux state and returns this session's sole exact active winlink. It returns [SnapshotLookupError] cardinality errors."},"source":{"file":"tmux/relations.go","line":83,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ResolveActiveWindow","product":"core","slug":"tmux-session-resolveactivewindow"},{"id":"tmux.Session.ResolveActivePane","name":"ResolveActivePane","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Pane, error)"}],"doc":{"summary":"ResolveActivePane returns the active pane in this session's active window, read live. It lists that session's panes rather than taking a whole-server snapshot, because a pane row already carries which window is active. It returns [SnapshotLookupError] cardinality errors, which match [ErrNotFound] when nothing was found."},"source":{"file":"tmux/relations.go","line":96,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.ResolveActivePane","product":"core","slug":"tmux-session-resolveactivepane"},{"id":"tmux.Window.ResolveSession","name":"ResolveSession","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Session, error)"}],"doc":{"summary":"ResolveSession snapshots live tmux state and returns this exact winlink's parent session. It returns [SnapshotLookupError] cardinality errors."},"source":{"file":"tmux/relations.go","line":139,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ResolveSession","product":"core","slug":"tmux-window-resolvesession"},{"id":"tmux.Window.ResolveActivePane","name":"ResolveActivePane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Pane, error)"}],"doc":{"summary":"ResolveActivePane returns the active pane in this exact winlink view, read live. It lists that window's panes rather than taking a whole-server snapshot. It returns [SnapshotLookupError] cardinality errors, which match [ErrNotFound] when nothing was found."},"source":{"file":"tmux/relations.go","line":156,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.ResolveActivePane","product":"core","slug":"tmux-window-resolveactivepane"},{"id":"tmux.Pane.ResolveWindow","name":"ResolveWindow","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"ResolveWindow snapshots live tmux state and returns the exact winlink containing this pane view. It returns [SnapshotLookupError] cardinality errors."},"source":{"file":"tmux/relations.go","line":175,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ResolveWindow","product":"core","slug":"tmux-pane-resolvewindow"},{"id":"tmux.Pane.ResolveSession","name":"ResolveSession","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Session, error)"}],"doc":{"summary":"ResolveSession snapshots live tmux state and returns the parent session of this pane's exact winlink. It returns [SnapshotLookupError] cardinality errors."},"source":{"file":"tmux/relations.go","line":185,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.ResolveSession","product":"core","slug":"tmux-pane-resolvesession"},{"id":"tmux.ErrMissingSubcommand","name":"ErrMissingSubcommand","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMissingSubcommand identifies an object command with no tmux subcommand."},"source":{"file":"tmux/scoped_command.go","line":9,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrMissingSubcommand","product":"core","slug":"tmux-errmissingsubcommand"},{"id":"tmux.Session.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(CommandResult, error)"}],"doc":{"summary":"Cmd executes a tmux subcommand targeted to the session's stable ID."},"source":{"file":"tmux/scoped_command.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Cmd","product":"core","slug":"tmux-session-cmd"},{"id":"tmux.Window.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(CommandResult, error)"}],"doc":{"summary":"Cmd executes a tmux subcommand targeted to the window's stable ID."},"source":{"file":"tmux/scoped_command.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Cmd","product":"core","slug":"tmux-window-cmd"},{"id":"tmux.Pane.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(CommandResult, error)"}],"doc":{"summary":"Cmd executes a tmux subcommand targeted to the pane's stable ID."},"source":{"file":"tmux/scoped_command.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Cmd","product":"core","slug":"tmux-pane-cmd"},{"id":"tmux.Server.SearchSessions","name":"SearchSessions","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Session, error)"}],"doc":{"summary":"SearchSessions returns a newly materialized snapshot projection of sessions selected by tmux's live -f expression. A nil filter omits -f; a nonnil empty filter remains an explicit empty expression."},"source":{"file":"tmux/search.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SearchSessions","product":"core","slug":"tmux-server-searchsessions"},{"id":"tmux.Server.SearchClients","name":"SearchClients","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Client, error)"}],"doc":{"summary":"SearchClients returns a newly materialized snapshot projection of clients selected by tmux's live -f expression. A nil filter omits -f and requests the unfiltered listing on every supported tmux version. A nonnil filter, including an empty expression, requires tmux 3.4 or newer and otherwise returns [VersionTooLowError]."},"source":{"file":"tmux/search.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SearchClients","product":"core","slug":"tmux-server-searchclients"},{"id":"tmux.Server.SearchWindows","name":"SearchWindows","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Window, error)"}],"doc":{"summary":"SearchWindows returns a newly materialized snapshot projection of winlinks selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression."},"source":{"file":"tmux/search.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SearchWindows","product":"core","slug":"tmux-server-searchwindows"},{"id":"tmux.Server.SearchPanes","name":"SearchPanes","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Pane, error)"}],"doc":{"summary":"SearchPanes returns a newly materialized snapshot projection of pane views selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression."},"source":{"file":"tmux/search.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SearchPanes","product":"core","slug":"tmux-server-searchpanes"},{"id":"tmux.Session.SearchWindows","name":"SearchWindows","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Window, error)"}],"doc":{"summary":"SearchWindows returns this session's winlinks selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression. The session's stable identity limits the projection."},"source":{"file":"tmux/search.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SearchWindows","product":"core","slug":"tmux-session-searchwindows"},{"id":"tmux.Session.SearchPanes","name":"SearchPanes","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Pane, error)"}],"doc":{"summary":"SearchPanes returns this session's pane views selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression. The session's stable identity limits the projection."},"source":{"file":"tmux/search.go","line":117,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SearchPanes","product":"core","slug":"tmux-session-searchpanes"},{"id":"tmux.Window.SearchPanes","name":"SearchPanes","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Pane, error)"}],"doc":{"summary":"SearchPanes returns this window's pane views selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression. Stable session and window identities limit the projection."},"source":{"file":"tmux/search.go","line":144,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SearchPanes","product":"core","slug":"tmux-window-searchpanes"},{"id":"tmux.Server","name":"Server","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Server is an immutable handle to one tmux configuration. Its zero value is invalid. Copying a configured Server preserves its configuration and shares version-cache coordination; only the documented concurrent operations are safe to share."},"source":{"file":"tmux/server.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server","product":"core","slug":"tmux-server"},{"id":"tmux.Server.SocketPath","name":"SocketPath","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"SocketPath returns the absolute socket path selected when the server was constructed. An invalid server returns an empty string."},"source":{"file":"tmux/server.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SocketPath","product":"core","slug":"tmux-server-socketpath"},{"id":"tmux.Server.ConfigFile","name":"ConfigFile","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"ConfigFile returns the configured tmux configuration path."},"source":{"file":"tmux/server.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ConfigFile","product":"core","slug":"tmux-server-configfile"},{"id":"tmux.Server.ProcessEnvironment","name":"ProcessEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"[]string"}],"doc":{"summary":"ProcessEnvironment returns the normalized environment explicitly supplied through [ServerOptions]. Nil means the server inherited a private process snapshot. The returned slice is owned by the caller; an invalid server returns nil."},"source":{"file":"tmux/server.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ProcessEnvironment","product":"core","slug":"tmux-server-processenvironment"},{"id":"tmux.Server.Executable","name":"Executable","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Executable returns the absolute tmux executable path resolved when the server was constructed. An invalid server returns an empty string."},"source":{"file":"tmux/server.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Executable","product":"core","slug":"tmux-server-executable"},{"id":"tmux.Server.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(CommandResult, error)"}],"doc":{"summary":"Cmd executes raw tmux arguments and returns caller-owned result slices. A completed nonzero exit remains a result; validation and transport failures return errors. Cancellation cannot prove whether a mutation reached tmux.","body":"An argument that is exactly \";\" separates two tmux commands, so one call can\nsubmit a command list. tmux runs a list until a command fails and drops the\nrest, and answers with one merged stdout, so a caller that needs to know\nwhich command produced which line submits them separately. A list means the\nsame thing through either execution binding.\n\nOnly a standalone \";\" separates commands. Other semicolons follow the selected\nbinding's parsing; typed operations keep values literal across bindings."},"source":{"file":"tmux/server.go","line":99,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Cmd","product":"core","slug":"tmux-server-cmd"},{"id":"tmux.Server.IsAlive","name":"IsAlive","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(bool, error)"}],"doc":{"summary":"IsAlive reports whether a tmux server answers on the configured socket. Only an absent server reports false without an error: a socket that exists but cannot be reached, such as one the process may not read, is a question that could not be answered and is returned as an error. Use [Server.CheckAlive] where an absent server is itself the failure."},"source":{"file":"tmux/server.go","line":145,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.IsAlive","product":"core","slug":"tmux-server-isalive"},{"id":"tmux.Server.CheckAlive","name":"CheckAlive","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CheckAlive returns a [CommandError] when the configured server is not alive. Cancellation and transport failures are returned directly. Use [Server.IsAlive] where an absent server is an answer rather than a failure."},"source":{"file":"tmux/server.go","line":164,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.CheckAlive","product":"core","slug":"tmux-server-checkalive"},{"id":"tmux.AttachSessionOptions","name":"AttachSessionOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"AttachSessionOptions configures terminal ownership and attach behavior shared by server- and session-scoped attachment. Nil StartDirectory omits its flag and a nonnil empty string is explicit; ClientFlags is copied. The Stdin, Stdout, and Stderr pointers are retained for the attach call and are never owned or closed by this package."},"source":{"file":"tmux/server_attach.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions","product":"core","slug":"tmux-attachsessionoptions"},{"id":"tmux.AttachSessionOptions.DetachOthers","name":"DetachOthers","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"bool","doc":{"summary":"DetachOthers disconnects other clients attached to the target session."},"source":{"file":"tmux/server_attach.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.DetachOthers","product":"core","slug":"tmux-attachsessionoptions-detachothers"},{"id":"tmux.AttachSessionOptions.DetachParent","name":"DetachParent","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"bool","doc":{"summary":"DetachParent detaches the invoking client from its parent session first."},"source":{"file":"tmux/server_attach.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.DetachParent","product":"core","slug":"tmux-attachsessionoptions-detachparent"},{"id":"tmux.AttachSessionOptions.NoUpdateEnvironment","name":"NoUpdateEnvironment","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"bool","doc":{"summary":"NoUpdateEnvironment preserves the invoking client's environment."},"source":{"file":"tmux/server_attach.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.NoUpdateEnvironment","product":"core","slug":"tmux-attachsessionoptions-noupdateenvironment"},{"id":"tmux.AttachSessionOptions.ReadOnly","name":"ReadOnly","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"bool","doc":{"summary":"ReadOnly attaches the client with read-only permissions."},"source":{"file":"tmux/server_attach.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.ReadOnly","product":"core","slug":"tmux-attachsessionoptions-readonly"},{"id":"tmux.AttachSessionOptions.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"*string","doc":{"summary":"StartDirectory selects the attached client's initial directory."},"source":{"file":"tmux/server_attach.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.StartDirectory","product":"core","slug":"tmux-attachsessionoptions-startdirectory"},{"id":"tmux.AttachSessionOptions.ClientFlags","name":"ClientFlags","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"[]string","doc":{"summary":"ClientFlags are comma-joined client flags copied before attachment starts."},"source":{"file":"tmux/server_attach.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.ClientFlags","product":"core","slug":"tmux-attachsessionoptions-clientflags"},{"id":"tmux.AttachSessionOptions.Stdin","name":"Stdin","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"*os.File","doc":{"summary":"Stdin is the attached tmux client's input stream; nil inherits process stdin."},"source":{"file":"tmux/server_attach.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.Stdin","product":"core","slug":"tmux-attachsessionoptions-stdin"},{"id":"tmux.AttachSessionOptions.Stdout","name":"Stdout","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"*os.File","doc":{"summary":"Stdout is the attached tmux client's output stream; nil inherits process stdout."},"source":{"file":"tmux/server_attach.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.Stdout","product":"core","slug":"tmux-attachsessionoptions-stdout"},{"id":"tmux.AttachSessionOptions.Stderr","name":"Stderr","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"*os.File","doc":{"summary":"Stderr is the attached tmux client's error stream; nil inherits process stderr."},"source":{"file":"tmux/server_attach.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionOptions.Stderr","product":"core","slug":"tmux-attachsessionoptions-stderr"},{"id":"tmux.AttachSessionRequest","name":"AttachSessionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"AttachSessionRequest selects a session name or tmux target pattern and configures a blocking terminal attachment. An empty Target lets tmux choose."},"source":{"file":"tmux/server_attach.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionRequest","product":"core","slug":"tmux-attachsessionrequest"},{"id":"tmux.AttachSessionRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionRequest","signatures":[],"type":"string","doc":{"summary":"Target is a session name or tmux target pattern; empty leaves selection to tmux."},"source":{"file":"tmux/server_attach.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.AttachSessionRequest.Target","product":"core","slug":"tmux-attachsessionrequest-target"},{"id":"tmux.Server.Start","name":"Start","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Start starts the configured tmux server. It is idempotent when that server is already running. Completed stderr is an error; cancellation does not prove that a daemon was not started.","body":"With tmux's exit-empty default, a server holding no sessions may exit before\nthe next command even though Start succeeded. Create a session or disable\nexit-empty in [ServerOptions.ConfigFile] before startup. Use [Server.IsAlive]\nor [Server.CheckAlive] to check it."},"source":{"file":"tmux/server_attach.go","line":70,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Start","product":"core","slug":"tmux-server-start"},{"id":"tmux.Server.AttachSession","name":"AttachSession","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"AttachSessionRequest"}],"returns":"error"}],"doc":{"summary":"AttachSession attaches the caller's terminal to a matching session and blocks until detach or context cancellation. Nil standard streams inherit the process streams; each stream must be a concrete terminal descriptor. The call retains caller-supplied files while attached and never owns or closes them. A completed nonzero exit returns [CommandError]; cancellation can end waiting but does not prove that attachment or detachment did not occur.","body":"Alone among this package's operations, it leaves tmux's own locale detection\nalone, because what tmux writes here reaches the caller's terminal rather\nthan this package. See [Session.Attach] for the session-scoped form."},"source":{"file":"tmux/server_attach.go","line":85,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.AttachSession","product":"core","slug":"tmux-server-attachsession"},{"id":"tmux.Session.Attach","name":"Attach","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"options","type":"AttachSessionOptions"}],"returns":"error"}],"doc":{"summary":"Attach attaches the caller's terminal to this session's stable identifier and blocks until detach or context cancellation. It validates the receiver's stable SessionID, retains but never closes caller-supplied streams, and returns [CommandError] for a completed nonzero exit. Cancellation does not prove attachment or detachment did not occur. It leaves tmux's own locale detection alone for the reason [Server.AttachSession] gives."},"source":{"file":"tmux/server_attach.go","line":99,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Attach","product":"core","slug":"tmux-session-attach"},{"id":"tmux.TmuxFilter","name":"TmuxFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TmuxFilter is a raw tmux -f format expression. It is distinct from the generated local filter structs and is evaluated only by tmux. A nil filter omits -f; a nonnil empty filter sends an explicit empty expression.","body":"The expression is tmux's own, so it is written the way tmux's FORMATS\nsection describes rather than built from Go values:\n\nactive := tmux.TmuxFilter(\"#{==:#{window_active},1}\")\nwindows, err := session.SearchWindows(ctx, &active)\n\ntmux evaluates this while listing. Generated model filters run in Go after\nmaterialization.\n\nrevive:disable-next-line:exported TmuxFilter preserves tmux vocabulary beside local model filters."},"source":{"file":"tmux/server_buffers.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TmuxFilter","product":"core","slug":"tmux-tmuxfilter"},{"id":"tmux.SetBufferRequest","name":"SetBufferRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetBufferRequest configures storing data in a tmux paste buffer. Its zero value writes an empty most-recent buffer; nil Name selects that buffer while a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetBufferRequest","product":"core","slug":"tmux-setbufferrequest"},{"id":"tmux.SetBufferRequest.Data","name":"Data","kind":"attribute","modifiers":[],"parent":"tmux.SetBufferRequest","signatures":[],"type":"string","doc":{"summary":"Data is the exact buffer data to store or append."},"source":{"file":"tmux/server_buffers.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetBufferRequest.Data","product":"core","slug":"tmux-setbufferrequest-data"},{"id":"tmux.SetBufferRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SetBufferRequest","signatures":[],"type":"*string","doc":{"summary":"Name selects a named buffer, or nil for tmux's most-recent buffer."},"source":{"file":"tmux/server_buffers.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetBufferRequest.Name","product":"core","slug":"tmux-setbufferrequest-name"},{"id":"tmux.SetBufferRequest.Append","name":"Append","kind":"attribute","modifiers":[],"parent":"tmux.SetBufferRequest","signatures":[],"type":"bool","doc":{"summary":"Append appends Data instead of replacing the selected buffer."},"source":{"file":"tmux/server_buffers.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SetBufferRequest.Append","product":"core","slug":"tmux-setbufferrequest-append"},{"id":"tmux.SaveBufferRequest","name":"SaveBufferRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SaveBufferRequest configures writing a tmux paste buffer to a file. Its zero value is invalid because Path is required; nil Name selects the most-recent buffer and a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SaveBufferRequest","product":"core","slug":"tmux-savebufferrequest"},{"id":"tmux.SaveBufferRequest.Path","name":"Path","kind":"attribute","modifiers":[],"parent":"tmux.SaveBufferRequest","signatures":[],"type":"string","doc":{"summary":"Path is the required output file path."},"source":{"file":"tmux/server_buffers.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SaveBufferRequest.Path","product":"core","slug":"tmux-savebufferrequest-path"},{"id":"tmux.SaveBufferRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SaveBufferRequest","signatures":[],"type":"*string","doc":{"summary":"Name selects a named buffer, or nil for tmux's most-recent buffer."},"source":{"file":"tmux/server_buffers.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SaveBufferRequest.Name","product":"core","slug":"tmux-savebufferrequest-name"},{"id":"tmux.SaveBufferRequest.Append","name":"Append","kind":"attribute","modifiers":[],"parent":"tmux.SaveBufferRequest","signatures":[],"type":"bool","doc":{"summary":"Append appends buffer data to Path instead of replacing its contents."},"source":{"file":"tmux/server_buffers.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SaveBufferRequest.Append","product":"core","slug":"tmux-savebufferrequest-append"},{"id":"tmux.LoadBufferRequest","name":"LoadBufferRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"LoadBufferRequest configures loading a file into a tmux paste buffer. Its zero value is invalid because Path is required; nil Name lets tmux allocate a buffer and a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LoadBufferRequest","product":"core","slug":"tmux-loadbufferrequest"},{"id":"tmux.LoadBufferRequest.Path","name":"Path","kind":"attribute","modifiers":[],"parent":"tmux.LoadBufferRequest","signatures":[],"type":"string","doc":{"summary":"Path is the required input file path."},"source":{"file":"tmux/server_buffers.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LoadBufferRequest.Path","product":"core","slug":"tmux-loadbufferrequest-path"},{"id":"tmux.LoadBufferRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.LoadBufferRequest","signatures":[],"type":"*string","doc":{"summary":"Name selects the destination buffer, or nil for tmux's allocation behavior."},"source":{"file":"tmux/server_buffers.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LoadBufferRequest.Name","product":"core","slug":"tmux-loadbufferrequest-name"},{"id":"tmux.LoadBufferFromOptions","name":"LoadBufferFromOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"LoadBufferFromOptions configures streaming data into a tmux paste buffer. Its zero value lets tmux allocate a buffer; nil Name selects that allocation and a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LoadBufferFromOptions","product":"core","slug":"tmux-loadbufferfromoptions"},{"id":"tmux.LoadBufferFromOptions.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.LoadBufferFromOptions","signatures":[],"type":"*string","doc":{"summary":"Name selects the destination buffer, or nil for tmux's allocation behavior."},"source":{"file":"tmux/server_buffers.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LoadBufferFromOptions.Name","product":"core","slug":"tmux-loadbufferfromoptions-name"},{"id":"tmux.SaveBufferToOptions","name":"SaveBufferToOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SaveBufferToOptions configures streaming a tmux paste buffer's contents out. Its zero value selects tmux's most-recent buffer; a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SaveBufferToOptions","product":"core","slug":"tmux-savebuffertooptions"},{"id":"tmux.SaveBufferToOptions.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SaveBufferToOptions","signatures":[],"type":"*string","doc":{"summary":"Name selects a named buffer, or nil for tmux's most-recent buffer."},"source":{"file":"tmux/server_buffers.go","line":73,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SaveBufferToOptions.Name","product":"core","slug":"tmux-savebuffertooptions-name"},{"id":"tmux.ListBuffersRequest","name":"ListBuffersRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ListBuffersRequest configures tmux's live paste-buffer listing. Its zero value requests tmux's default output; nil Format and Filter omit their flags, whereas pointers to empty strings are explicit expressions."},"source":{"file":"tmux/server_buffers.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ListBuffersRequest","product":"core","slug":"tmux-listbuffersrequest"},{"id":"tmux.ListBuffersRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.ListBuffersRequest","signatures":[],"type":"*string","doc":{"summary":"Format selects tmux's output format."},"source":{"file":"tmux/server_buffers.go","line":81,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ListBuffersRequest.Format","product":"core","slug":"tmux-listbuffersrequest-format"},{"id":"tmux.ListBuffersRequest.Filter","name":"Filter","kind":"attribute","modifiers":[],"parent":"tmux.ListBuffersRequest","signatures":[],"type":"*TmuxFilter","doc":{"summary":"Filter is a raw tmux filter expression evaluated by tmux."},"source":{"file":"tmux/server_buffers.go","line":83,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ListBuffersRequest.Filter","product":"core","slug":"tmux-listbuffersrequest-filter"},{"id":"tmux.Server.SetBuffer","name":"SetBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SetBufferRequest"}],"returns":"error"}],"doc":{"summary":"SetBuffer stores or appends exact string data without refreshing models. It mutates the selected paste buffer; completed stderr is reported as a redacted command error because Data may be secret. Cancellation does not prove that tmux did not store data."},"source":{"file":"tmux/server_buffers.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SetBuffer","product":"core","slug":"tmux-server-setbuffer"},{"id":"tmux.Server.ShowBuffer","name":"ShowBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"*string"}],"returns":"(string, error)"}],"doc":{"summary":"ShowBuffer returns one buffer using Python-compatible line reconstruction. The returned string is owned by the caller; nil Name selects tmux's most recent buffer. Completed stderr is an error."},"source":{"file":"tmux/server_buffers.go","line":118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ShowBuffer","product":"core","slug":"tmux-server-showbuffer"},{"id":"tmux.Server.ShowBufferBytes","name":"ShowBufferBytes","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"*string"}],"returns":"([]byte, error)"}],"doc":{"summary":"ShowBufferBytes returns one buffer as exact caller-owned tmux stdout bytes. Unlike [Server.ShowBuffer], it preserves invalid UTF-8, delimiters, and trailing newlines. Nil Name selects tmux's most recent buffer. Completed stderr returns a redacted command error and a nil byte slice."},"source":{"file":"tmux/server_buffers.go","line":130,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ShowBufferBytes","product":"core","slug":"tmux-server-showbufferbytes"},{"id":"tmux.Server.DeleteBuffer","name":"DeleteBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"*string"}],"returns":"error"}],"doc":{"summary":"DeleteBuffer deletes a named buffer, or the most recent buffer when name is nil. Cancellation does not prove that tmux did not delete the buffer."},"source":{"file":"tmux/server_buffers.go","line":157,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.DeleteBuffer","product":"core","slug":"tmux-server-deletebuffer"},{"id":"tmux.Server.SaveBuffer","name":"SaveBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SaveBufferRequest"}],"returns":"error"}],"doc":{"summary":"SaveBuffer writes a named or most-recent buffer to a file. Path follows [Server.SourceFile]'s current-user expansion and lexical normalization. It changes that file. Exact \"-\" is rejected because it names tmux's stdout rather than a path; [Server.SaveBufferTo] streams to an [io.Writer], and this method is the one that runs over a [Connection]."},"source":{"file":"tmux/server_buffers.go","line":174,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SaveBuffer","product":"core","slug":"tmux-server-savebuffer"},{"id":"tmux.Server.LoadBuffer","name":"LoadBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"LoadBufferRequest"}],"returns":"error"}],"doc":{"summary":"LoadBuffer reads a file into a named or newly allocated buffer. Path follows [Server.SourceFile]'s current-user expansion and lexical normalization. It mutates tmux's destination buffer. Exact \"-\" is rejected because it names tmux's stdin rather than a path; [Server.LoadBufferFrom] streams from an [io.Reader], and this method is the one that runs over a [Connection]."},"source":{"file":"tmux/server_buffers.go","line":199,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.LoadBuffer","product":"core","slug":"tmux-server-loadbuffer"},{"id":"tmux.Server.LoadBufferFrom","name":"LoadBufferFrom","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"source","type":"io.Reader"},{"name":"options","type":"LoadBufferFromOptions"}],"returns":"error"}],"doc":{"summary":"LoadBufferFrom streams source into a named or newly allocated tmux paste buffer, reading it to completion without holding its contents in memory. It carries any bytes, including NUL, and is bounded by neither argv nor tmux's command-message limit, which is what [Server.SetBuffer] is bounded by.","body":"A copy failure after tmux exits zero means the buffer holds only the prefix\nthat reached tmux, and cancellation does not prove tmux stored nothing. A\nsource that blocks regardless of cancellation does not hold the call, and is\nstill being read when it returns. A [Connection]-bound Server returns\n[ErrConnectionRequiresProcess]: tmux offers no stdin to a control client, so\nuse [Server.LoadBuffer] and a path over a connection."},"source":{"file":"tmux/server_buffers.go","line":227,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.LoadBufferFrom","product":"core","slug":"tmux-server-loadbufferfrom"},{"id":"tmux.Server.SaveBufferTo","name":"SaveBufferTo","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"destination","type":"io.Writer"},{"name":"options","type":"SaveBufferToOptions"}],"returns":"error"}],"doc":{"summary":"SaveBufferTo streams a named or most-recent tmux paste buffer into destination without holding its contents in memory. It writes any bytes, including NUL, and preserves them exactly where [Server.ShowBuffer] reconstructs lines.","body":"Cancellation does not prove destination received a complete buffer, and a\ncopy failure takes precedence over a completed command's exit status because\nit means destination never saw everything tmux sent. A destination that\nblocks regardless of cancellation does not hold the call. A\n[Connection]-bound Server returns [ErrConnectionRequiresProcess]: tmux\noffers no stdout to a control client, so use [Server.SaveBuffer] and a path\nover a connection."},"source":{"file":"tmux/server_buffers.go","line":259,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SaveBufferTo","product":"core","slug":"tmux-server-savebufferto"},{"id":"tmux.Server.ListBuffers","name":"ListBuffers","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ListBuffersRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ListBuffers returns an owned snapshot of live tmux buffer rows. A command or transport failure is returned rather than answered with no rows; context cancellation still returns its context error. The result is not a live collection."},"source":{"file":"tmux/server_buffers.go","line":283,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ListBuffers","product":"core","slug":"tmux-server-listbuffers"},{"id":"tmux.ServerAccessRequest","name":"ServerAccessRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerAccessRequest configures tmux server access control. Its zero value is invalid: List or exactly one nonempty Allow or Deny is required. Allow and Deny, and ReadOnly and Write, are mutually exclusive; nil pointers omit their selectors while explicit empty users are rejected. List selects the returned-list path, but compatible selector and mode flags are still sent to tmux rather than ignored."},"source":{"file":"tmux/server_clients.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerAccessRequest","product":"core","slug":"tmux-serveraccessrequest"},{"id":"tmux.ServerAccessRequest.Allow","name":"Allow","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"*string","doc":{"summary":"Allow grants the named user access."},"source":{"file":"tmux/server_clients.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerAccessRequest.Allow","product":"core","slug":"tmux-serveraccessrequest-allow"},{"id":"tmux.ServerAccessRequest.Deny","name":"Deny","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"*string","doc":{"summary":"Deny revokes the named user's access."},"source":{"file":"tmux/server_clients.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerAccessRequest.Deny","product":"core","slug":"tmux-serveraccessrequest-deny"},{"id":"tmux.ServerAccessRequest.List","name":"List","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"bool","doc":{"summary":"List returns the configured access entries instead of mutating them."},"source":{"file":"tmux/server_clients.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerAccessRequest.List","product":"core","slug":"tmux-serveraccessrequest-list"},{"id":"tmux.ServerAccessRequest.ReadOnly","name":"ReadOnly","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"bool","doc":{"summary":"ReadOnly grants read-only access to the selected user."},"source":{"file":"tmux/server_clients.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerAccessRequest.ReadOnly","product":"core","slug":"tmux-serveraccessrequest-readonly"},{"id":"tmux.ServerAccessRequest.Write","name":"Write","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"bool","doc":{"summary":"Write grants write access to the selected user."},"source":{"file":"tmux/server_clients.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerAccessRequest.Write","product":"core","slug":"tmux-serveraccessrequest-write"},{"id":"tmux.RefreshClientRequest","name":"RefreshClientRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RefreshClientRequest configures refreshing one tmux client. Its zero value refreshes tmux's current client; a zero TargetClient omits -t."},"source":{"file":"tmux/server_clients.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RefreshClientRequest","product":"core","slug":"tmux-refreshclientrequest"},{"id":"tmux.RefreshClientRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.RefreshClientRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects a stable client; zero selects tmux's current client."},"source":{"file":"tmux/server_clients.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RefreshClientRequest.TargetClient","product":"core","slug":"tmux-refreshclientrequest-targetclient"},{"id":"tmux.RefreshClientRequest.RequestClipboard","name":"RequestClipboard","kind":"attribute","modifiers":[],"parent":"tmux.RefreshClientRequest","signatures":[],"type":"bool","doc":{"summary":"RequestClipboard requests clipboard data and requires tmux 3.4; older tmux versions may exit when given the flag, so it follows UnsupportedPolicy."},"source":{"file":"tmux/server_clients.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RefreshClientRequest.RequestClipboard","product":"core","slug":"tmux-refreshclientrequest-requestclipboard"},{"id":"tmux.DetachClientRequest","name":"DetachClientRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DetachClientRequest configures detaching one tmux client. Its zero value detaches tmux's current client; nil fields omit their flags while an empty ShellCommand pointer is explicit."},"source":{"file":"tmux/server_clients.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachClientRequest","product":"core","slug":"tmux-detachclientrequest"},{"id":"tmux.DetachClientRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.DetachClientRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects a stable client; zero selects tmux's current client."},"source":{"file":"tmux/server_clients.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachClientRequest.TargetClient","product":"core","slug":"tmux-detachclientrequest-targetclient"},{"id":"tmux.DetachClientRequest.ShellCommand","name":"ShellCommand","kind":"attribute","modifiers":[],"parent":"tmux.DetachClientRequest","signatures":[],"type":"*string","doc":{"summary":"ShellCommand is run after detaching when nonnil."},"source":{"file":"tmux/server_clients.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachClientRequest.ShellCommand","product":"core","slug":"tmux-detachclientrequest-shellcommand"},{"id":"tmux.DetachAllClientsRequest","name":"DetachAllClientsRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DetachAllClientsRequest configures detaching every client except one. Its zero value keeps tmux's current client; nil fields omit their flags."},"source":{"file":"tmux/server_clients.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachAllClientsRequest","product":"core","slug":"tmux-detachallclientsrequest"},{"id":"tmux.DetachAllClientsRequest.KeepClient","name":"KeepClient","kind":"attribute","modifiers":[],"parent":"tmux.DetachAllClientsRequest","signatures":[],"type":"ClientName","doc":{"summary":"KeepClient selects the stable client to retain; zero keeps tmux's current client."},"source":{"file":"tmux/server_clients.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachAllClientsRequest.KeepClient","product":"core","slug":"tmux-detachallclientsrequest-keepclient"},{"id":"tmux.DetachAllClientsRequest.ShellCommand","name":"ShellCommand","kind":"attribute","modifiers":[],"parent":"tmux.DetachAllClientsRequest","signatures":[],"type":"*string","doc":{"summary":"ShellCommand is run after detaching when nonnil."},"source":{"file":"tmux/server_clients.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DetachAllClientsRequest.ShellCommand","product":"core","slug":"tmux-detachallclientsrequest-shellcommand"},{"id":"tmux.Server.ServerAccess","name":"ServerAccess","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ServerAccessRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ServerAccess changes or lists the server access-control entries. It requires tmux 3.3 and returns [VersionTooLowError] below that floor. List returns an owned snapshot, and reports a completed or transport failure rather than answering with no entries; mutation completed stderr is an error."},"source":{"file":"tmux/server_clients.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ServerAccess","product":"core","slug":"tmux-server-serveraccess"},{"id":"tmux.Server.LockServer","name":"LockServer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"LockServer locks every attached client on the tmux server. Cancellation does not prove the server did not lock a client."},"source":{"file":"tmux/server_clients.go","line":151,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.LockServer","product":"core","slug":"tmux-server-lockserver"},{"id":"tmux.Server.RefreshClient","name":"RefreshClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RefreshClientRequest"}],"returns":"error"}],"doc":{"summary":"RefreshClient redraws a client, or tmux's current client when no target is set. RequestClipboard requires tmux 3.4 and follows [UnsupportedPolicy]."},"source":{"file":"tmux/server_clients.go","line":157,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.RefreshClient","product":"core","slug":"tmux-server-refreshclient"},{"id":"tmux.Server.LockClient","name":"LockClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"targetClient","type":"*ClientName"}],"returns":"error"}],"doc":{"summary":"LockClient locks a client, or tmux's current client when targetClient is nil. Cancellation does not prove the target client was not locked."},"source":{"file":"tmux/server_clients.go","line":191,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.LockClient","product":"core","slug":"tmux-server-lockclient"},{"id":"tmux.Server.SuspendClient","name":"SuspendClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"targetClient","type":"*ClientName"}],"returns":"error"}],"doc":{"summary":"SuspendClient suspends a client, or tmux's current client when targetClient is nil. Cancellation does not prove suspension did not occur."},"source":{"file":"tmux/server_clients.go","line":205,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SuspendClient","product":"core","slug":"tmux-server-suspendclient"},{"id":"tmux.Server.DetachClient","name":"DetachClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DetachClientRequest"}],"returns":"error"}],"doc":{"summary":"DetachClient detaches one client, or tmux's current client when no target is set. A completed stderr result is an error; cancellation does not prove delivery or detachment did not occur."},"source":{"file":"tmux/server_clients.go","line":220,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.DetachClient","product":"core","slug":"tmux-server-detachclient"},{"id":"tmux.Server.DetachAllClients","name":"DetachAllClients","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DetachAllClientsRequest"}],"returns":"error"}],"doc":{"summary":"DetachAllClients detaches every client except KeepClient or tmux's current client. Cancellation does not prove every client was detached."},"source":{"file":"tmux/server_clients.go","line":245,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.DetachAllClients","product":"core","slug":"tmux-server-detachallclients"},{"id":"tmux.Server.SwitchClient","name":"SwitchClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"targetSession","type":"string"}],"returns":"error"}],"doc":{"summary":"SwitchClient switches tmux's current client to targetSession. TargetSession is a validated session name rather than a stable identity; cancellation does not prove the switch did not occur."},"source":{"file":"tmux/server_clients.go","line":274,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SwitchClient","product":"core","slug":"tmux-server-switchclient"},{"id":"tmux.Session.Lock","name":"Lock","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Lock locks every client attached to the session identified by this handle's stable ID. Cancellation does not prove that tmux did not lock a client."},"source":{"file":"tmux/server_clients.go","line":288,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Lock","product":"core","slug":"tmux-session-lock"},{"id":"tmux.Session.DetachClients","name":"DetachClients","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"shellCommand","type":"*string"}],"returns":"error"}],"doc":{"summary":"DetachClients detaches every client attached to the session identified by this handle's stable ID. A nonnil ShellCommand is run after detaching."},"source":{"file":"tmux/server_clients.go","line":309,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.DetachClients","product":"core","slug":"tmux-session-detachclients"},{"id":"tmux.Session.SwitchClient","name":"SwitchClient","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"SwitchClient switches tmux's current client to the session identified by this handle's stable ID."},"source":{"file":"tmux/server_clients.go","line":338,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SwitchClient","product":"core","slug":"tmux-session-switchclient"},{"id":"tmux.ErrInvalidServerCommandRequest","name":"ErrInvalidServerCommandRequest","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidServerCommandRequest identifies a server command request that cannot be represented safely as tmux arguments."},"source":{"file":"tmux/server_exec.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidServerCommandRequest","product":"core","slug":"tmux-errinvalidservercommandrequest"},{"id":"tmux.ServerCommandRequestError","name":"ServerCommandRequestError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerCommandRequestError reports a locally rejected server command request field. Callers can use [errors.Is] with [ErrInvalidServerCommandRequest] or [errors.As] to inspect it. Value is redacted only when that field's validator requests redaction."},"source":{"file":"tmux/server_exec.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerCommandRequestError","product":"core","slug":"tmux-servercommandrequesterror"},{"id":"tmux.ServerCommandRequestError.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[],"type":"string","doc":{"summary":"Subcommand is the tmux command whose request was rejected."},"source":{"file":"tmux/server_exec.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerCommandRequestError.Subcommand","product":"core","slug":"tmux-servercommandrequesterror-subcommand"},{"id":"tmux.ServerCommandRequestError.Field","name":"Field","kind":"attribute","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[],"type":"string","doc":{"summary":"Field is the request field that was rejected."},"source":{"file":"tmux/server_exec.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerCommandRequestError.Field","product":"core","slug":"tmux-servercommandrequesterror-field"},{"id":"tmux.ServerCommandRequestError.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[],"type":"string","doc":{"summary":"Value is the rejected value, or \"[redacted]\" for a secret-sensitive field."},"source":{"file":"tmux/server_exec.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerCommandRequestError.Value","product":"core","slug":"tmux-servercommandrequesterror-value"},{"id":"tmux.ServerCommandRequestError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[],"type":"string","doc":{"summary":"Reason describes the validation failure without changing the sentinel error."},"source":{"file":"tmux/server_exec.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerCommandRequestError.Reason","product":"core","slug":"tmux-servercommandrequesterror-reason"},{"id":"tmux.ServerCommandRequestError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/server_exec.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerCommandRequestError.Error","product":"core","slug":"tmux-servercommandrequesterror-error"},{"id":"tmux.ServerCommandRequestError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ServerCommandRequestError compatible with ErrInvalidServerCommandRequest."},"source":{"file":"tmux/server_exec.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerCommandRequestError.Unwrap","product":"core","slug":"tmux-servercommandrequesterror-unwrap"},{"id":"tmux.RunShellRequest","name":"RunShellRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RunShellRequest configures a command executed by tmux's run-shell command. Its zero value is invalid because Command is required. Pointer fields distinguish omitted flags from explicit empty arguments; RunShell copies Delay, StartDirectory, and Args before invoking tmux."},"source":{"file":"tmux/server_exec.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest","product":"core","slug":"tmux-runshellrequest"},{"id":"tmux.RunShellRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"string","doc":{"summary":"Command is the required shell or tmux command to run."},"source":{"file":"tmux/server_exec.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest.Command","product":"core","slug":"tmux-runshellrequest-command"},{"id":"tmux.RunShellRequest.Background","name":"Background","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"bool","doc":{"summary":"Background returns after tmux accepts the job instead of waiting for stdout."},"source":{"file":"tmux/server_exec.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest.Background","product":"core","slug":"tmux-runshellrequest-background"},{"id":"tmux.RunShellRequest.Delay","name":"Delay","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"*string","doc":{"summary":"Delay supplies run-shell's optional delay; nil omits it and an empty value is explicit."},"source":{"file":"tmux/server_exec.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest.Delay","product":"core","slug":"tmux-runshellrequest-delay"},{"id":"tmux.RunShellRequest.AsTmuxCommand","name":"AsTmuxCommand","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"bool","doc":{"summary":"AsTmuxCommand asks tmux to interpret Command as tmux command syntax."},"source":{"file":"tmux/server_exec.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest.AsTmuxCommand","product":"core","slug":"tmux-runshellrequest-astmuxcommand"},{"id":"tmux.RunShellRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"PaneID","doc":{"summary":"TargetPane selects a stable pane target; its zero value leaves target selection to tmux."},"source":{"file":"tmux/server_exec.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest.TargetPane","product":"core","slug":"tmux-runshellrequest-targetpane"},{"id":"tmux.RunShellRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"*string","doc":{"summary":"StartDirectory selects the job directory; nil omits it. It requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_exec.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest.StartDirectory","product":"core","slug":"tmux-runshellrequest-startdirectory"},{"id":"tmux.RunShellRequest.ShowStderr","name":"ShowStderr","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"bool","doc":{"summary":"ShowStderr requests job stderr and requires tmux 3.6; see UnsupportedPolicy."},"source":{"file":"tmux/server_exec.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest.ShowStderr","product":"core","slug":"tmux-runshellrequest-showstderr"},{"id":"tmux.RunShellRequest.Args","name":"Args","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"[]string","doc":{"summary":"Args are extra job arguments copied before tmux runs. They require tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/server_exec.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunShellRequest.Args","product":"core","slug":"tmux-runshellrequest-args"},{"id":"tmux.WaitForMode","name":"WaitForMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WaitForMode selects one wait-for operation. The zero value waits until the channel is signaled."},"source":{"file":"tmux/server_exec.go","line":85,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WaitForMode","product":"core","slug":"tmux-waitformode"},{"id":"tmux.WaitForModeWait","name":"WaitForModeWait","kind":"constant","modifiers":[],"signatures":[],"type":"WaitForMode","doc":{"summary":"WaitForModeWait waits until another client signals Channel."},"source":{"file":"tmux/server_exec.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WaitForModeWait","product":"core","slug":"tmux-waitformodewait"},{"id":"tmux.WaitForModeSignal","name":"WaitForModeSignal","kind":"constant","modifiers":[],"signatures":[],"type":"WaitForMode","doc":{"summary":"WaitForModeSignal signals Channel and wakes waiters."},"source":{"file":"tmux/server_exec.go","line":92,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WaitForModeSignal","product":"core","slug":"tmux-waitformodesignal"},{"id":"tmux.WaitForModeLock","name":"WaitForModeLock","kind":"constant","modifiers":[],"signatures":[],"type":"WaitForMode","doc":{"summary":"WaitForModeLock acquires Channel's tmux mutex, queuing behind another locker if it is already held.","body":"A cancelled or timed-out ctx while queued costs Channel one unlock:\ntmux hands the mutex to the next queued client whether or not it is\nstill there, and the one that has gone cannot pass it on\n(cmd-wait-for.c cmd_wait_for_unlock). Unlocking again hands it to the\nnext real locker, so a channel is not lost, but a program that\nabandons lock waits and counts its unlocks will deadlock on its own\narithmetic."},"source":{"file":"tmux/server_exec.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WaitForModeLock","product":"core","slug":"tmux-waitformodelock"},{"id":"tmux.WaitForModeUnlock","name":"WaitForModeUnlock","kind":"constant","modifiers":[],"signatures":[],"type":"WaitForMode","doc":{"summary":"WaitForModeUnlock releases Channel's tmux mutex."},"source":{"file":"tmux/server_exec.go","line":105,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WaitForModeUnlock","product":"core","slug":"tmux-waitformodeunlock"},{"id":"tmux.WaitForRequest","name":"WaitForRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WaitForRequest configures a wait, signal, lock, or unlock operation. Its zero value waits on the required nonempty Channel."},"source":{"file":"tmux/server_exec.go","line":110,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WaitForRequest","product":"core","slug":"tmux-waitforrequest"},{"id":"tmux.WaitForRequest.Channel","name":"Channel","kind":"attribute","modifiers":[],"parent":"tmux.WaitForRequest","signatures":[],"type":"string","doc":{"summary":"Channel names the tmux wait-for channel or mutex."},"source":{"file":"tmux/server_exec.go","line":112,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WaitForRequest.Channel","product":"core","slug":"tmux-waitforrequest-channel"},{"id":"tmux.WaitForRequest.Mode","name":"Mode","kind":"attribute","modifiers":[],"parent":"tmux.WaitForRequest","signatures":[],"type":"WaitForMode","doc":{"summary":"Mode selects the channel action; zero waits."},"source":{"file":"tmux/server_exec.go","line":114,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WaitForRequest.Mode","product":"core","slug":"tmux-waitforrequest-mode"},{"id":"tmux.IfShellRequest","name":"IfShellRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"IfShellRequest configures conditional execution of a tmux command. Its zero value is invalid because ShellCommand and ThenCommand are required; nil ElseCommand omits the failure branch while a pointer to an empty string is explicit."},"source":{"file":"tmux/server_exec.go","line":121,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.IfShellRequest","product":"core","slug":"tmux-ifshellrequest"},{"id":"tmux.IfShellRequest.ShellCommand","name":"ShellCommand","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"string","doc":{"summary":"ShellCommand is the required shell condition executed by tmux."},"source":{"file":"tmux/server_exec.go","line":123,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.IfShellRequest.ShellCommand","product":"core","slug":"tmux-ifshellrequest-shellcommand"},{"id":"tmux.IfShellRequest.ThenCommand","name":"ThenCommand","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"string","doc":{"summary":"ThenCommand is the required tmux command executed when ShellCommand succeeds."},"source":{"file":"tmux/server_exec.go","line":125,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.IfShellRequest.ThenCommand","product":"core","slug":"tmux-ifshellrequest-thencommand"},{"id":"tmux.IfShellRequest.ElseCommand","name":"ElseCommand","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"*string","doc":{"summary":"ElseCommand is the optional tmux command executed when ShellCommand fails."},"source":{"file":"tmux/server_exec.go","line":127,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.IfShellRequest.ElseCommand","product":"core","slug":"tmux-ifshellrequest-elsecommand"},{"id":"tmux.IfShellRequest.Background","name":"Background","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"bool","doc":{"summary":"Background makes tmux schedule the conditional command without waiting."},"source":{"file":"tmux/server_exec.go","line":129,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.IfShellRequest.Background","product":"core","slug":"tmux-ifshellrequest-background"},{"id":"tmux.IfShellRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"PaneID","doc":{"summary":"TargetPane selects a stable pane target; its zero value omits -t."},"source":{"file":"tmux/server_exec.go","line":131,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.IfShellRequest.TargetPane","product":"core","slug":"tmux-ifshellrequest-targetpane"},{"id":"tmux.SourceFileRequest","name":"SourceFileRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SourceFileRequest configures loading or parsing a tmux configuration file. Its zero value is invalid because Path is required; SourceFile expands only the current user's ~ forms and copies no caller-owned mutable input."},"source":{"file":"tmux/server_exec.go","line":137,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SourceFileRequest","product":"core","slug":"tmux-sourcefilerequest"},{"id":"tmux.SourceFileRequest.Path","name":"Path","kind":"attribute","modifiers":[],"parent":"tmux.SourceFileRequest","signatures":[],"type":"string","doc":{"summary":"Path is the required configuration path; exact \"-\" is rejected because no stdin is provided."},"source":{"file":"tmux/server_exec.go","line":139,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SourceFileRequest.Path","product":"core","slug":"tmux-sourcefilerequest-path"},{"id":"tmux.SourceFileRequest.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.SourceFileRequest","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux diagnostics for missing source files."},"source":{"file":"tmux/server_exec.go","line":141,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SourceFileRequest.Quiet","product":"core","slug":"tmux-sourcefilerequest-quiet"},{"id":"tmux.SourceFileRequest.ParseOnly","name":"ParseOnly","kind":"attribute","modifiers":[],"parent":"tmux.SourceFileRequest","signatures":[],"type":"bool","doc":{"summary":"ParseOnly validates the file without applying its commands."},"source":{"file":"tmux/server_exec.go","line":143,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SourceFileRequest.ParseOnly","product":"core","slug":"tmux-sourcefilerequest-parseonly"},{"id":"tmux.SourceFileRequest.Verbose","name":"Verbose","kind":"attribute","modifiers":[],"parent":"tmux.SourceFileRequest","signatures":[],"type":"bool","doc":{"summary":"Verbose requests tmux parsing diagnostics."},"source":{"file":"tmux/server_exec.go","line":145,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SourceFileRequest.Verbose","product":"core","slug":"tmux-sourcefilerequest-verbose"},{"id":"tmux.Server.RunShell","name":"RunShell","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RunShellRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"RunShell executes a shell command through tmux and returns an owned stdout slice. A background request returns nil after tmux accepts the job. Unsupported optional flags follow [UnsupportedPolicy]. A completed stderr result is an error; context cancellation can be observed with [errors.Is] but does not establish that tmux did not start the job."},"source":{"file":"tmux/server_exec.go","line":153,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.RunShell","product":"core","slug":"tmux-server-runshell"},{"id":"tmux.Server.WaitFor","name":"WaitFor","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"WaitForRequest"}],"returns":"error"}],"doc":{"summary":"WaitFor waits for, signals, locks, or unlocks a named tmux channel. It changes only that server-side channel state; cancellation can interrupt the client wait but cannot prove a preceding signal or lock did not take effect. See [WaitForModeLock]: abandoning a lock wait costs that channel one unlock."},"source":{"file":"tmux/server_exec.go","line":249,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.WaitFor","product":"core","slug":"tmux-server-waitfor"},{"id":"tmux.Server.IfShell","name":"IfShell","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"IfShellRequest"}],"returns":"error"}],"doc":{"summary":"IfShell executes ThenCommand when ShellCommand succeeds and ElseCommand, if present, when it fails. A completed stderr result is an error; cancellation can interrupt delivery without proving that tmux did not execute a branch."},"source":{"file":"tmux/server_exec.go","line":283,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.IfShell","product":"core","slug":"tmux-server-ifshell"},{"id":"tmux.Server.SourceFile","name":"SourceFile","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SourceFileRequest"}],"returns":"error"}],"doc":{"summary":"SourceFile loads or parses one tmux configuration file. The path expands ~ and ~/... for the current user and normalizes redundant separators and dot components without collapsing parent components. Named-user forms are rejected. Exact \"-\" is rejected because it requires process stdin; a relative path naming a file called \"-\" remains file data. It can mutate tmux configuration; completed stderr is an error, and cancellation does not prove that parsing or sourcing did not occur."},"source":{"file":"tmux/server_exec.go","line":323,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SourceFile","product":"core","slug":"tmux-server-sourcefile"},{"id":"tmux.ConfirmBeforeRequest","name":"ConfirmBeforeRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ConfirmBeforeRequest configures a background tmux confirmation prompt. Its zero value is invalid because Command is required. Nil pointer fields omit their flags while explicit empty strings are passed to tmux; ConfirmKey must be one printable ASCII character."},"source":{"file":"tmux/server_interactive.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ConfirmBeforeRequest","product":"core","slug":"tmux-confirmbeforerequest"},{"id":"tmux.ConfirmBeforeRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"string","doc":{"summary":"Command is the required tmux command shown for confirmation."},"source":{"file":"tmux/server_interactive.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ConfirmBeforeRequest.Command","product":"core","slug":"tmux-confirmbeforerequest-command"},{"id":"tmux.ConfirmBeforeRequest.Prompt","name":"Prompt","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"*string","doc":{"summary":"Prompt replaces tmux's prompt when nonnil."},"source":{"file":"tmux/server_interactive.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ConfirmBeforeRequest.Prompt","product":"core","slug":"tmux-confirmbeforerequest-prompt"},{"id":"tmux.ConfirmBeforeRequest.ConfirmKey","name":"ConfirmKey","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"*string","doc":{"summary":"ConfirmKey selects the affirmative key and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ConfirmBeforeRequest.ConfirmKey","product":"core","slug":"tmux-confirmbeforerequest-confirmkey"},{"id":"tmux.ConfirmBeforeRequest.DefaultYes","name":"DefaultYes","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"bool","doc":{"summary":"DefaultYes selects yes by default and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ConfirmBeforeRequest.DefaultYes","product":"core","slug":"tmux-confirmbeforerequest-defaultyes"},{"id":"tmux.ConfirmBeforeRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the stable client that displays the prompt."},"source":{"file":"tmux/server_interactive.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ConfirmBeforeRequest.TargetClient","product":"core","slug":"tmux-confirmbeforerequest-targetclient"},{"id":"tmux.CommandPromptRequest","name":"CommandPromptRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandPromptRequest configures a background tmux command prompt. Its zero value is invalid because Template is required; nil pointer fields omit flags while explicit empty values are passed to tmux."},"source":{"file":"tmux/server_interactive.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest","product":"core","slug":"tmux-commandpromptrequest"},{"id":"tmux.CommandPromptRequest.Template","name":"Template","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"string","doc":{"summary":"Template is the required tmux command template submitted by the prompt."},"source":{"file":"tmux/server_interactive.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.Template","product":"core","slug":"tmux-commandpromptrequest-template"},{"id":"tmux.CommandPromptRequest.Prompt","name":"Prompt","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"*string","doc":{"summary":"Prompt replaces tmux's prompt text when nonnil."},"source":{"file":"tmux/server_interactive.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.Prompt","product":"core","slug":"tmux-commandpromptrequest-prompt"},{"id":"tmux.CommandPromptRequest.Inputs","name":"Inputs","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"*string","doc":{"summary":"Inputs supplies initial prompt inputs when nonnil."},"source":{"file":"tmux/server_interactive.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.Inputs","product":"core","slug":"tmux-commandpromptrequest-inputs"},{"id":"tmux.CommandPromptRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the stable client that displays the prompt."},"source":{"file":"tmux/server_interactive.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.TargetClient","product":"core","slug":"tmux-commandpromptrequest-targetclient"},{"id":"tmux.CommandPromptRequest.OneKey","name":"OneKey","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"OneKey accepts one key rather than a line."},"source":{"file":"tmux/server_interactive.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.OneKey","product":"core","slug":"tmux-commandpromptrequest-onekey"},{"id":"tmux.CommandPromptRequest.KeyOnly","name":"KeyOnly","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"KeyOnly limits accepted input to keys."},"source":{"file":"tmux/server_interactive.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.KeyOnly","product":"core","slug":"tmux-commandpromptrequest-keyonly"},{"id":"tmux.CommandPromptRequest.OnInputChange","name":"OnInputChange","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"OnInputChange runs Template after each input change."},"source":{"file":"tmux/server_interactive.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.OnInputChange","product":"core","slug":"tmux-commandpromptrequest-oninputchange"},{"id":"tmux.CommandPromptRequest.Numeric","name":"Numeric","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"Numeric restricts accepted input to a number."},"source":{"file":"tmux/server_interactive.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.Numeric","product":"core","slug":"tmux-commandpromptrequest-numeric"},{"id":"tmux.CommandPromptRequest.Type","name":"Type","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"PromptType","doc":{"summary":"Type selects the associated prompt-history class; zero omits -T."},"source":{"file":"tmux/server_interactive.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.Type","product":"core","slug":"tmux-commandpromptrequest-type"},{"id":"tmux.CommandPromptRequest.ExpandFormat","name":"ExpandFormat","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"ExpandFormat expands formats in the prompt result."},"source":{"file":"tmux/server_interactive.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.ExpandFormat","product":"core","slug":"tmux-commandpromptrequest-expandformat"},{"id":"tmux.CommandPromptRequest.Literal","name":"Literal","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"Literal disables key-name parsing and requires tmux 3.6; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.Literal","product":"core","slug":"tmux-commandpromptrequest-literal"},{"id":"tmux.CommandPromptRequest.BackspaceExit","name":"BackspaceExit","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"BackspaceExit exits on backspace and requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":64,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.BackspaceExit","product":"core","slug":"tmux-commandpromptrequest-backspaceexit"},{"id":"tmux.CommandPromptRequest.NoFreeze","name":"NoFreeze","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"NoFreeze leaves the pane unfrozen and requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.CommandPromptRequest.NoFreeze","product":"core","slug":"tmux-commandpromptrequest-nofreeze"},{"id":"tmux.MenuItem","name":"MenuItem","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MenuItem is one display-menu entry. Its zero value is a separator. A named item always contributes its name, key, and command to tmux, including empty key or command strings."},"source":{"file":"tmux/server_interactive.go","line":73,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuItem","product":"core","slug":"tmux-menuitem"},{"id":"tmux.MenuItem.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.MenuItem","signatures":[],"type":"string","doc":{"summary":"Name is the visible item name; an empty name makes this item a separator."},"source":{"file":"tmux/server_interactive.go","line":75,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuItem.Name","product":"core","slug":"tmux-menuitem-name"},{"id":"tmux.MenuItem.Key","name":"Key","kind":"attribute","modifiers":[],"parent":"tmux.MenuItem","signatures":[],"type":"string","doc":{"summary":"Key is the optional shortcut for a named item."},"source":{"file":"tmux/server_interactive.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuItem.Key","product":"core","slug":"tmux-menuitem-key"},{"id":"tmux.MenuItem.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.MenuItem","signatures":[],"type":"string","doc":{"summary":"Command is the tmux command for a named item."},"source":{"file":"tmux/server_interactive.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MenuItem.Command","product":"core","slug":"tmux-menuitem-command"},{"id":"tmux.DisplayMenuRequest","name":"DisplayMenuRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DisplayMenuRequest configures one tmux popup menu. Position and style strings retain tmux's format and symbolic-position languages verbatim. Its zero value is invalid because Items is required. All pointer fields omit their flags when nil and retain explicit empty strings; DisplayMenu copies Items before calling tmux. TargetPane and TargetClient are independent but must be stable identities when present."},"source":{"file":"tmux/server_interactive.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest","product":"core","slug":"tmux-displaymenurequest"},{"id":"tmux.DisplayMenuRequest.Items","name":"Items","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"[]MenuItem","doc":{"summary":"Items are menu rows; a zero MenuItem is a separator."},"source":{"file":"tmux/server_interactive.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.Items","product":"core","slug":"tmux-displaymenurequest-items"},{"id":"tmux.DisplayMenuRequest.Title","name":"Title","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"Title is the optional menu title."},"source":{"file":"tmux/server_interactive.go","line":92,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.Title","product":"core","slug":"tmux-displaymenurequest-title"},{"id":"tmux.DisplayMenuRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"PaneID","doc":{"summary":"TargetPane supplies pane context for format expansion."},"source":{"file":"tmux/server_interactive.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.TargetPane","product":"core","slug":"tmux-displaymenurequest-targetpane"},{"id":"tmux.DisplayMenuRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the client that renders the menu."},"source":{"file":"tmux/server_interactive.go","line":96,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.TargetClient","product":"core","slug":"tmux-displaymenurequest-targetclient"},{"id":"tmux.DisplayMenuRequest.X","name":"X","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"X is tmux's horizontal position expression."},"source":{"file":"tmux/server_interactive.go","line":98,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.X","product":"core","slug":"tmux-displaymenurequest-x"},{"id":"tmux.DisplayMenuRequest.Y","name":"Y","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"Y is tmux's vertical position expression."},"source":{"file":"tmux/server_interactive.go","line":100,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.Y","product":"core","slug":"tmux-displaymenurequest-y"},{"id":"tmux.DisplayMenuRequest.StartingChoice","name":"StartingChoice","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"StartingChoice selects the initial item and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.StartingChoice","product":"core","slug":"tmux-displaymenurequest-startingchoice"},{"id":"tmux.DisplayMenuRequest.BorderLines","name":"BorderLines","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"BorderLines selects border glyphs and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.BorderLines","product":"core","slug":"tmux-displaymenurequest-borderlines"},{"id":"tmux.DisplayMenuRequest.Style","name":"Style","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"Style selects menu style and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.Style","product":"core","slug":"tmux-displaymenurequest-style"},{"id":"tmux.DisplayMenuRequest.BorderStyle","name":"BorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"BorderStyle selects border style and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.BorderStyle","product":"core","slug":"tmux-displaymenurequest-borderstyle"},{"id":"tmux.DisplayMenuRequest.SelectedStyle","name":"SelectedStyle","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"SelectedStyle selects highlighted-item style and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":114,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.SelectedStyle","product":"core","slug":"tmux-displaymenurequest-selectedstyle"},{"id":"tmux.DisplayMenuRequest.Mouse","name":"Mouse","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"bool","doc":{"summary":"Mouse enables mouse selection and requires tmux 3.5; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":116,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.Mouse","product":"core","slug":"tmux-displaymenurequest-mouse"},{"id":"tmux.DisplayMenuRequest.StayOpen","name":"StayOpen","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"bool","doc":{"summary":"StayOpen keeps the menu visible after selecting an item."},"source":{"file":"tmux/server_interactive.go","line":118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DisplayMenuRequest.StayOpen","product":"core","slug":"tmux-displaymenurequest-stayopen"},{"id":"tmux.Server.ConfirmBefore","name":"ConfirmBefore","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ConfirmBeforeRequest"}],"returns":"error"}],"doc":{"summary":"ConfirmBefore asks tmux to display a background confirmation prompt and returns after tmux accepts it, not after the user answers or Command runs. It requires tmux 3.3. ConfirmKey and DefaultYes require tmux 3.4 and follow [UnsupportedPolicy]. Completed stderr is an error; cancellation does not prove prompt delivery or later command execution did not occur."},"source":{"file":"tmux/server_interactive.go","line":183,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ConfirmBefore","product":"core","slug":"tmux-server-confirmbefore"},{"id":"tmux.Server.CommandPrompt","name":"CommandPrompt","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"CommandPromptRequest"}],"returns":"error"}],"doc":{"summary":"CommandPrompt asks tmux to display a background command prompt and returns after tmux accepts it, not after input is submitted or Template runs. It requires tmux 3.3. Later flags follow [UnsupportedPolicy]. Completed stderr is an error; cancellation does not prove prompt delivery or later execution."},"source":{"file":"tmux/server_interactive.go","line":231,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.CommandPrompt","product":"core","slug":"tmux-server-commandprompt"},{"id":"tmux.Server.DisplayMenu","name":"DisplayMenu","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayMenuRequest"}],"returns":"error"}],"doc":{"summary":"DisplayMenu displays a menu and waits until tmux closes it. The target client must own a TTY; control-mode clients cannot render menu overlays. It returns no selected value and does not establish whether an item command ran. Unsupported optional flags follow [UnsupportedPolicy]. Completed stderr is an error, and cancellation does not prove menu delivery or a selected command's effect."},"source":{"file":"tmux/server_interactive.go","line":311,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.DisplayMenu","product":"core","slug":"tmux-server-displaymenu"},{"id":"tmux.BindKeyRequest","name":"BindKeyRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"BindKeyRequest configures one tmux key binding. Its zero value is invalid because Key is required; nil KeyTable and Note omit their flags while pointers to empty strings are explicit."},"source":{"file":"tmux/server_keys.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BindKeyRequest","product":"core","slug":"tmux-bindkeyrequest"},{"id":"tmux.BindKeyRequest.Key","name":"Key","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"string","doc":{"summary":"Key is the required tmux key notation to bind."},"source":{"file":"tmux/server_keys.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BindKeyRequest.Key","product":"core","slug":"tmux-bindkeyrequest-key"},{"id":"tmux.BindKeyRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"string","doc":{"summary":"Command is the tmux command; an empty command is a no-op binding on tmux 3.3+."},"source":{"file":"tmux/server_keys.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BindKeyRequest.Command","product":"core","slug":"tmux-bindkeyrequest-command"},{"id":"tmux.BindKeyRequest.KeyTable","name":"KeyTable","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"*string","doc":{"summary":"KeyTable selects a table, or nil for tmux's default table."},"source":{"file":"tmux/server_keys.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BindKeyRequest.KeyTable","product":"core","slug":"tmux-bindkeyrequest-keytable"},{"id":"tmux.BindKeyRequest.Note","name":"Note","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"*string","doc":{"summary":"Note supplies tmux's optional binding note."},"source":{"file":"tmux/server_keys.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BindKeyRequest.Note","product":"core","slug":"tmux-bindkeyrequest-note"},{"id":"tmux.BindKeyRequest.Repeat","name":"Repeat","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"bool","doc":{"summary":"Repeat makes the binding repeatable."},"source":{"file":"tmux/server_keys.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.BindKeyRequest.Repeat","product":"core","slug":"tmux-bindkeyrequest-repeat"},{"id":"tmux.UnbindKeyRequest","name":"UnbindKeyRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"UnbindKeyRequest selects one key or an entire key table to unbind. Exactly one of Key and AllKeys must be set."},"source":{"file":"tmux/server_keys.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnbindKeyRequest","product":"core","slug":"tmux-unbindkeyrequest"},{"id":"tmux.UnbindKeyRequest.Key","name":"Key","kind":"attribute","modifiers":[],"parent":"tmux.UnbindKeyRequest","signatures":[],"type":"*string","doc":{"summary":"Key selects one binding; it is mutually exclusive with AllKeys."},"source":{"file":"tmux/server_keys.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnbindKeyRequest.Key","product":"core","slug":"tmux-unbindkeyrequest-key"},{"id":"tmux.UnbindKeyRequest.KeyTable","name":"KeyTable","kind":"attribute","modifiers":[],"parent":"tmux.UnbindKeyRequest","signatures":[],"type":"*string","doc":{"summary":"KeyTable limits removal to one table; nil selects tmux's default table."},"source":{"file":"tmux/server_keys.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnbindKeyRequest.KeyTable","product":"core","slug":"tmux-unbindkeyrequest-keytable"},{"id":"tmux.UnbindKeyRequest.AllKeys","name":"AllKeys","kind":"attribute","modifiers":[],"parent":"tmux.UnbindKeyRequest","signatures":[],"type":"bool","doc":{"summary":"AllKeys removes every binding in KeyTable and is mutually exclusive with Key."},"source":{"file":"tmux/server_keys.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnbindKeyRequest.AllKeys","product":"core","slug":"tmux-unbindkeyrequest-allkeys"},{"id":"tmux.UnbindKeyRequest.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.UnbindKeyRequest","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux's missing-binding diagnostic."},"source":{"file":"tmux/server_keys.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnbindKeyRequest.Quiet","product":"core","slug":"tmux-unbindkeyrequest-quiet"},{"id":"tmux.ListKeysRequest","name":"ListKeysRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ListKeysRequest configures raw key-binding output. Its zero value selects tmux's default table and format; nil fields omit flags while explicit empty pointers are passed to tmux."},"source":{"file":"tmux/server_keys.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ListKeysRequest","product":"core","slug":"tmux-listkeysrequest"},{"id":"tmux.ListKeysRequest.KeyTable","name":"KeyTable","kind":"attribute","modifiers":[],"parent":"tmux.ListKeysRequest","signatures":[],"type":"*string","doc":{"summary":"KeyTable limits output to one key table."},"source":{"file":"tmux/server_keys.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ListKeysRequest.KeyTable","product":"core","slug":"tmux-listkeysrequest-keytable"},{"id":"tmux.ListKeysRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.ListKeysRequest","signatures":[],"type":"*string","doc":{"summary":"Format selects output format and requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/server_keys.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ListKeysRequest.Format","product":"core","slug":"tmux-listkeysrequest-format"},{"id":"tmux.ListCommandsRequest","name":"ListCommandsRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ListCommandsRequest optionally limits output to one tmux command or alias. Nil CommandName lists all commands; a pointer to an empty name is explicit."},"source":{"file":"tmux/server_keys.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ListCommandsRequest","product":"core","slug":"tmux-listcommandsrequest"},{"id":"tmux.ListCommandsRequest.CommandName","name":"CommandName","kind":"attribute","modifiers":[],"parent":"tmux.ListCommandsRequest","signatures":[],"type":"*string","doc":{"summary":"CommandName optionally selects one command or alias."},"source":{"file":"tmux/server_keys.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ListCommandsRequest.CommandName","product":"core","slug":"tmux-listcommandsrequest-commandname"},{"id":"tmux.ShowMessagesRequest","name":"ShowMessagesRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ShowMessagesRequest selects the target and server information to print. Terminals and Jobs are independent and may both be enabled."},"source":{"file":"tmux/server_keys.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ShowMessagesRequest","product":"core","slug":"tmux-showmessagesrequest"},{"id":"tmux.ShowMessagesRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.ShowMessagesRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects a stable client; zero selects tmux's current client."},"source":{"file":"tmux/server_keys.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ShowMessagesRequest.TargetClient","product":"core","slug":"tmux-showmessagesrequest-targetclient"},{"id":"tmux.ShowMessagesRequest.Terminals","name":"Terminals","kind":"attribute","modifiers":[],"parent":"tmux.ShowMessagesRequest","signatures":[],"type":"bool","doc":{"summary":"Terminals includes terminal capability information."},"source":{"file":"tmux/server_keys.go","line":62,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ShowMessagesRequest.Terminals","product":"core","slug":"tmux-showmessagesrequest-terminals"},{"id":"tmux.ShowMessagesRequest.Jobs","name":"Jobs","kind":"attribute","modifiers":[],"parent":"tmux.ShowMessagesRequest","signatures":[],"type":"bool","doc":{"summary":"Jobs includes job status information."},"source":{"file":"tmux/server_keys.go","line":64,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ShowMessagesRequest.Jobs","product":"core","slug":"tmux-showmessagesrequest-jobs"},{"id":"tmux.Server.BindKey","name":"BindKey","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"BindKeyRequest"}],"returns":"error"}],"doc":{"summary":"BindKey binds Key to Command in a tmux key table. An empty Command creates a no-op binding on tmux 3.3 or newer; tmux 3.2a reports its upstream error. It mutates the table; cancellation does not prove that tmux did not bind Key."},"source":{"file":"tmux/server_keys.go","line":70,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.BindKey","product":"core","slug":"tmux-server-bindkey"},{"id":"tmux.Server.UnbindKey","name":"UnbindKey","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"UnbindKeyRequest"}],"returns":"error"}],"doc":{"summary":"UnbindKey removes one key binding or every binding in a key table. Key and AllKeys must select exactly one target; cancellation does not prove removal did not occur."},"source":{"file":"tmux/server_keys.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.UnbindKey","product":"core","slug":"tmux-server-unbindkey"},{"id":"tmux.Server.ListKeys","name":"ListKeys","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ListKeysRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ListKeys returns an owned snapshot of raw tmux key-binding lines. Format requires tmux 3.7 and follows [UnsupportedPolicy]. tmux 3.7 through 3.7c send a table's sole matching binding to client status and leave stdout empty; this method preserves that upstream and Python behavior. Listing failures remain errors.","body":"On an unused socket, tmux starts an empty server to answer. With the default\nexit-empty setting, that server exits at once and leaves its socket file."},"source":{"file":"tmux/server_keys.go","line":149,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ListKeys","product":"core","slug":"tmux-server-listkeys"},{"id":"tmux.Server.ListCommands","name":"ListCommands","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ListCommandsRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ListCommands returns an owned snapshot of raw tmux command-description lines. A list failure is returned rather than answered with no rows. Like [Server.ListKeys], it answers on a socket holding no server."},"source":{"file":"tmux/server_keys.go","line":189,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ListCommands","product":"core","slug":"tmux-server-listcommands"},{"id":"tmux.Server.ListClients","name":"ListClients","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]string, error)"}],"doc":{"summary":"ListClients returns an owned snapshot of raw tmux client-description lines, the text tmux itself prints. A list failure is returned rather than answered with no rows. [Server.Clients] answers the same question as typed [Client] records and is what most callers want."},"source":{"file":"tmux/server_keys.go","line":211,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ListClients","product":"core","slug":"tmux-server-listclients"},{"id":"tmux.Server.ShowMessages","name":"ShowMessages","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ShowMessagesRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ShowMessages returns an owned snapshot of the tmux message log, terminal capabilities, job summary, or both terminal and job summaries. A zero TargetClient selects tmux's current client; a list failure is returned rather than answered with no rows."},"source":{"file":"tmux/server_keys.go","line":218,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.ShowMessages","product":"core","slug":"tmux-server-showmessages"},{"id":"tmux.ErrInvalidServer","name":"ErrInvalidServer","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidServer identifies an operation on an uninitialized [Server]."},"source":{"file":"tmux/server_options.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidServer","product":"core","slug":"tmux-errinvalidserver"},{"id":"tmux.ErrInvalidServerOptions","name":"ErrInvalidServerOptions","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidServerOptions identifies a value that fails [ServerOptions] validation. Executable lookup and working-directory failures retain their own error identities."},"source":{"file":"tmux/server_options.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidServerOptions","product":"core","slug":"tmux-errinvalidserveroptions"},{"id":"tmux.ServerOptions","name":"ServerOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerOptions configures a [Server] without starting tmux. [NewServer] snapshots the effective environment, working directory, and executable; callers retain ownership of every supplied value."},"source":{"file":"tmux/server_options.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions","product":"core","slug":"tmux-serveroptions"},{"id":"tmux.ServerOptions.Binary","name":"Binary","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"string","doc":{"summary":"Binary is the tmux executable name or path. Empty resolves tmux once through the snapshotted PATH. Relative paths resolve against the constructor's working directory. The resolved absolute path is shared by subprocess and control-mode transports."},"source":{"file":"tmux/server_options.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.Binary","product":"core","slug":"tmux-serveroptions-binary"},{"id":"tmux.ServerOptions.SocketName","name":"SocketName","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"string","doc":{"summary":"SocketName selects tmux's named socket. SocketPath takes precedence."},"source":{"file":"tmux/server_options.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.SocketName","product":"core","slug":"tmux-serveroptions-socketname"},{"id":"tmux.ServerOptions.SocketPath","name":"SocketPath","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"string","doc":{"summary":"SocketPath selects an explicit tmux socket path."},"source":{"file":"tmux/server_options.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.SocketPath","product":"core","slug":"tmux-serveroptions-socketpath"},{"id":"tmux.ServerOptions.ConfigFile","name":"ConfigFile","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"string","doc":{"summary":"ConfigFile selects an exact tmux configuration file. Empty lets tmux read its default configuration, so a program inherits whatever the user running it has configured: a base-index other than zero, a prompt that appears in captured pane text, hooks that fire on the sessions this program creates. Point it at a file the program owns, which may be an empty one, when the tmux it drives should not depend on that."},"source":{"file":"tmux/server_options.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.ConfigFile","product":"core","slug":"tmux-serveroptions-configfile"},{"id":"tmux.ServerOptions.Colors","name":"Colors","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"ColorMode","doc":{"summary":"Colors overrides tmux's terminal color capability."},"source":{"file":"tmux/server_options.go","line":42,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.Colors","product":"core","slug":"tmux-serveroptions-colors"},{"id":"tmux.ServerOptions.ProcessEnvironment","name":"ProcessEnvironment","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"[]string","doc":{"summary":"ProcessEnvironment replaces the child process environment. Nil snapshots the current process environment. A non-nil empty slice supplies no caller-provided variables. Execution may add variables required by Go's target platform and a canonical TMUX_TMPDIR that freezes named or default socket selection. Duplicate names retain their last value. Entries containing NUL are rejected except on Plan 9, where NUL separates path-list elements. NewServer clones the slice."},"source":{"file":"tmux/server_options.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.ProcessEnvironment","product":"core","slug":"tmux-serveroptions-processenvironment"},{"id":"tmux.ServerOptions.Unsupported","name":"Unsupported","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"UnsupportedPolicy","doc":{"summary":"Unsupported selects what happens when a request needs an optional tmux capability the running server does not have. The zero value refuses the request; see UnsupportedPolicy."},"source":{"file":"tmux/server_options.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.Unsupported","product":"core","slug":"tmux-serveroptions-unsupported"},{"id":"tmux.ServerOptions.WarningHandler","name":"WarningHandler","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"WarningHandler","doc":{"summary":"WarningHandler receives nonfatal compatibility warnings. Nil discards warnings. See WarningHandler for delivery and concurrency semantics."},"source":{"file":"tmux/server_options.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.WarningHandler","product":"core","slug":"tmux-serveroptions-warninghandler"},{"id":"tmux.ServerOptions.CommandObserver","name":"CommandObserver","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"CommandObserver","doc":{"summary":"CommandObserver receives one record per tmux command run. Nil observes nothing. See CommandObserver for delivery and concurrency semantics."},"source":{"file":"tmux/server_options.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ServerOptions.CommandObserver","product":"core","slug":"tmux-serveroptions-commandobserver"},{"id":"tmux.NewServer","name":"NewServer","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"options","type":"ServerOptions"}],"returns":"(Server, error)"}],"doc":{"summary":"NewServer validates and snapshots one tmux configuration without starting tmux. Empty socket selectors use the endpoint selected by the frozen environment."},"source":{"file":"tmux/server_options.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewServer","product":"core","slug":"tmux-newserver"},{"id":"tmux.Server.WithSocketPath","name":"WithSocketPath","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"path","type":"string"}],"returns":"(Server, error)"}],"doc":{"summary":"WithSocketPath returns a server using path and the receiver's frozen executable, environment, working directory, and server-option policy. Empty clears explicit socket selectors and leaves endpoint selection to tmux. The result has fresh daemon-scoped coordination. A connection-bound receiver is rejected because its transport belongs to the original daemon."},"source":{"file":"tmux/server_options.go","line":106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.WithSocketPath","product":"core","slug":"tmux-server-withsocketpath"},{"id":"tmux.Server.WithProcessEnvironmentValue","name":"WithProcessEnvironmentValue","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(Server, error)"}],"doc":{"summary":"WithProcessEnvironmentValue returns a server whose tmux subprocesses receive name=value while preserving the receiver's frozen executable, configuration, and exact socket endpoint. It does not expose an inherited environment snapshot through [Server.ProcessEnvironment]. The result shares daemon-scoped coordination with the receiver. A connection-bound receiver is rejected."},"source":{"file":"tmux/server_options.go","line":134,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.WithProcessEnvironmentValue","product":"core","slug":"tmux-server-withprocessenvironmentvalue"},{"id":"tmux.ErrVersionQuery","name":"ErrVersionQuery","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrVersionQuery identifies a tmux version probe that produced no usable version. It is matched by errors.Is for VersionQueryError."},"source":{"file":"tmux/server_version.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrVersionQuery","product":"core","slug":"tmux-errversionquery"},{"id":"tmux.ErrVersionTooLow","name":"ErrVersionTooLow","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrVersionTooLow identifies a tmux version below a required feature level. It is matched by errors.Is for VersionTooLowError."},"source":{"file":"tmux/server_version.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrVersionTooLow","product":"core","slug":"tmux-errversiontoolow"},{"id":"tmux.VersionQueryError","name":"VersionQueryError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VersionQueryError reports an unsuccessful tmux -V probe. It matches [ErrVersionQuery] through errors.Is; callers can recover its fields with errors.As. Library-created errors retain only the exit code; command arguments and output are omitted, although callers may construct values with other contents."},"source":{"file":"tmux/server_version.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionQueryError","product":"core","slug":"tmux-versionqueryerror"},{"id":"tmux.VersionQueryError.Result","name":"Result","kind":"attribute","modifiers":[],"parent":"tmux.VersionQueryError","signatures":[],"type":"CommandResult","doc":{"summary":"Result contains the library-created error's exit code and no diagnostics."},"source":{"file":"tmux/server_version.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionQueryError.Result","product":"core","slug":"tmux-versionqueryerror-result"},{"id":"tmux.VersionQueryError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.VersionQueryError","signatures":[],"type":"string","doc":{"summary":"Reason describes a malformed successful probe result, when applicable."},"source":{"file":"tmux/server_version.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionQueryError.Reason","product":"core","slug":"tmux-versionqueryerror-reason"},{"id":"tmux.VersionQueryError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.VersionQueryError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/server_version.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionQueryError.Error","product":"core","slug":"tmux-versionqueryerror-error"},{"id":"tmux.VersionQueryError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.VersionQueryError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes VersionQueryError compatible with ErrVersionQuery."},"source":{"file":"tmux/server_version.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionQueryError.Unwrap","product":"core","slug":"tmux-versionqueryerror-unwrap"},{"id":"tmux.VersionTooLowError","name":"VersionTooLowError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VersionTooLowError reports the installed and required tmux feature levels. It matches [ErrVersionTooLow] through errors.Is; callers can recover its fields with errors.As.","body":"Subcommand and Feature are set when one optional capability within a command\nwas refused rather than the command itself, which is what\n[UnsupportedPolicy] governs."},"source":{"file":"tmux/server_version.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionTooLowError","product":"core","slug":"tmux-versiontoolowerror"},{"id":"tmux.VersionTooLowError.Current","name":"Current","kind":"attribute","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[],"type":"Version","doc":{"summary":"Current is the installed tmux feature level."},"source":{"file":"tmux/server_version.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionTooLowError.Current","product":"core","slug":"tmux-versiontoolowerror-current"},{"id":"tmux.VersionTooLowError.Minimum","name":"Minimum","kind":"attribute","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[],"type":"Version","doc":{"summary":"Minimum is the requested minimum feature level."},"source":{"file":"tmux/server_version.go","line":81,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionTooLowError.Minimum","product":"core","slug":"tmux-versiontoolowerror-minimum"},{"id":"tmux.VersionTooLowError.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[],"type":"string","doc":{"summary":"Subcommand names the tmux subcommand whose optional capability was refused. Empty when the command itself is below its floor."},"source":{"file":"tmux/server_version.go","line":84,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionTooLowError.Subcommand","product":"core","slug":"tmux-versiontoolowerror-subcommand"},{"id":"tmux.VersionTooLowError.Feature","name":"Feature","kind":"attribute","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[],"type":"string","doc":{"summary":"Feature names the refused optional capability. Empty when the command itself is below its floor."},"source":{"file":"tmux/server_version.go","line":87,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionTooLowError.Feature","product":"core","slug":"tmux-versiontoolowerror-feature"},{"id":"tmux.VersionTooLowError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/server_version.go","line":91,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionTooLowError.Error","product":"core","slug":"tmux-versiontoolowerror-error"},{"id":"tmux.VersionTooLowError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes VersionTooLowError compatible with ErrVersionTooLow."},"source":{"file":"tmux/server_version.go","line":111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionTooLowError.Unwrap","product":"core","slug":"tmux-versiontoolowerror-unwrap"},{"id":"tmux.Server.Version","name":"Version","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Version, error)"}],"doc":{"summary":"Version returns the configured tmux binary's cached version. Failed probes are not cached. A waiting caller can abandon an in-flight shared probe when ctx ends without canceling the caller that owns the probe."},"source":{"file":"tmux/server_version.go","line":152,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Version","product":"core","slug":"tmux-server-version"},{"id":"tmux.Server.RefreshVersion","name":"RefreshVersion","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Version, error)"}],"doc":{"summary":"RefreshVersion invalidates the cached version and probes the binary again. Canceling ctx stops this call's wait; it does not establish whether a probe reached the configured binary."},"source":{"file":"tmux/server_version.go","line":159,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.RefreshVersion","product":"core","slug":"tmux-server-refreshversion"},{"id":"tmux.Server.RequireVersion","name":"RequireVersion","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"minimum","type":"Version"}],"returns":"error"}],"doc":{"summary":"RequireVersion returns a [VersionTooLowError] matching [ErrVersionTooLow] when the configured binary is older than minimum."},"source":{"file":"tmux/server_version.go","line":165,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.RequireVersion","product":"core","slug":"tmux-server-requireversion"},{"id":"tmux.ErrSessionExists","name":"ErrSessionExists","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrSessionExists identifies a named session that was not replaced."},"source":{"file":"tmux/session_lifecycle.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrSessionExists","product":"core","slug":"tmux-errsessionexists"},{"id":"tmux.HasSessionRequest","name":"HasSessionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"HasSessionRequest selects exact or tmux-pattern session matching on tmux 3.2a or later. Its zero value is invalid because Target is required."},"source":{"file":"tmux/session_lifecycle.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.HasSessionRequest","product":"core","slug":"tmux-hassessionrequest"},{"id":"tmux.HasSessionRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.HasSessionRequest","signatures":[],"type":"string","doc":{"summary":"Target is the required session name or tmux session pattern."},"source":{"file":"tmux/session_lifecycle.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.HasSessionRequest.Target","product":"core","slug":"tmux-hassessionrequest-target"},{"id":"tmux.HasSessionRequest.Pattern","name":"Pattern","kind":"attribute","modifiers":[],"parent":"tmux.HasSessionRequest","signatures":[],"type":"bool","doc":{"summary":"Pattern lets tmux interpret Target as a pattern; false requires an exact session name."},"source":{"file":"tmux/session_lifecycle.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.HasSessionRequest.Pattern","product":"core","slug":"tmux-hassessionrequest-pattern"},{"id":"tmux.NewSessionRequest","name":"NewSessionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NewSessionRequest configures session creation. [Server.NewSession] creates a detached session; [Server.NewSessionConnection] creates one attached to its first control-mode lane. Its zero value uses tmux defaults. Width and Height are either zero or 1 through 65535; KillExisting requires Name. KillExisting may remove a session before a later creation failure.","body":"[Server.NewSession] copies Environment before validation and retains no map\nstorage; concurrent mutation during the copy is unsafe. Foreground-only tmux\nflags are not exposed."},"source":{"file":"tmux/session_lifecycle.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest","product":"core","slug":"tmux-newsessionrequest"},{"id":"tmux.NewSessionRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"string","doc":{"summary":"Name selects the new session name; empty lets tmux generate one."},"source":{"file":"tmux/session_lifecycle.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest.Name","product":"core","slug":"tmux-newsessionrequest-name"},{"id":"tmux.NewSessionRequest.KillExisting","name":"KillExisting","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"bool","doc":{"summary":"KillExisting removes an existing session named Name before creation."},"source":{"file":"tmux/session_lifecycle.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest.KillExisting","product":"core","slug":"tmux-newsessionrequest-killexisting"},{"id":"tmux.NewSessionRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Named-user forms such as ~other are rejected; empty inherits tmux's default."},"source":{"file":"tmux/session_lifecycle.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest.StartDirectory","product":"core","slug":"tmux-newsessionrequest-startdirectory"},{"id":"tmux.NewSessionRequest.WindowName","name":"WindowName","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"string","doc":{"summary":"WindowName names the initial window; empty lets tmux choose."},"source":{"file":"tmux/session_lifecycle.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest.WindowName","product":"core","slug":"tmux-newsessionrequest-windowname"},{"id":"tmux.NewSessionRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"int","doc":{"summary":"Width sets the detached session width; zero lets tmux choose."},"source":{"file":"tmux/session_lifecycle.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest.Width","product":"core","slug":"tmux-newsessionrequest-width"},{"id":"tmux.NewSessionRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"int","doc":{"summary":"Height sets the detached session height; zero lets tmux choose."},"source":{"file":"tmux/session_lifecycle.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest.Height","product":"core","slug":"tmux-newsessionrequest-height"},{"id":"tmux.NewSessionRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order. The map is not retained; nil and an empty map both add no entries."},"source":{"file":"tmux/session_lifecycle.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest.Environment","product":"core","slug":"tmux-newsessionrequest-environment"},{"id":"tmux.NewSessionRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"string","doc":{"summary":"Command starts the initial pane with this shell command; empty uses tmux's default command."},"source":{"file":"tmux/session_lifecycle.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSessionRequest.Command","product":"core","slug":"tmux-newsessionrequest-command"},{"id":"tmux.Server.HasSession","name":"HasSession","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"HasSessionRequest"}],"returns":"(bool, error)"}],"doc":{"summary":"HasSession reports whether Target selects a session. With Pattern false it compares session names exactly; with Pattern true, tmux may resolve IDs, client TTYs, unique prefixes, or globs. Pattern-mode completed nonzero exits are misses. Exact-name lookup treats [ErrNoServer] as a miss and returns other failures.","body":"Exact-name lookup lists sessions because tmux's exact-match marker still\nresolves identifiers and client TTYs."},"source":{"file":"tmux/session_lifecycle.go","line":128,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.HasSession","product":"core","slug":"tmux-server-hassession"},{"id":"tmux.Server.NewSession","name":"NewSession","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewSessionRequest"}],"returns":"(Session, error)"}],"doc":{"summary":"NewSession creates a detached session, then returns a newly materialized [Session]. It never changes client focus. KillExisting is not rolled back; transport and context failures may be delivery-ambiguous.","body":"The returned record has unmaterialized [Session.Windows] and [Session.Panes]\nrelations. Use the resolvers or [Server.Snapshot] when relations are needed.\n\nIf tmux reports an ID before a transport or refresh failure, the returned\npartial Session contains its [Server] and [SessionID]. Other failures return zero."},"source":{"file":"tmux/session_lifecycle.go","line":184,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.NewSession","product":"core","slug":"tmux-server-newsession"},{"id":"tmux.Session.Rename","name":"Rename","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(Session, error)"}],"doc":{"summary":"Rename changes the receiver session's name and returns a canonical freshly materialized [Session]. If the command succeeds but refresh fails, it returns the receiver with that error. A transport or context error can be delivery-ambiguous; no rollback is attempted. Invalid names are rejected before execution and match [ErrInvalidRequest]."},"source":{"file":"tmux/session_lifecycle.go","line":261,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Rename","product":"core","slug":"tmux-session-rename"},{"id":"tmux.ValidateSessionName","name":"ValidateSessionName","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"ValidateSessionName reports whether name can be used as a tmux session name. Empty names, the target delimiters '.' and ':', control characters and invalid UTF-8 are rejected."},"source":{"file":"tmux/session_lifecycle.go","line":310,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ValidateSessionName","product":"core","slug":"tmux-validatesessionname"},{"id":"tmux.SelectWindowRequest","name":"SelectWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SelectWindowRequest selects one winlink in a [Session] on tmux 3.2a or later. Its zero value is invalid: exactly one of WindowID and Index is required. That mutual exclusion, stable-ID syntax, and a nonnegative Index are validated before execution. Index is read during the call and is not retained; nil omits it, a nonnil pointer is explicit, and callers must not mutate it concurrently."},"source":{"file":"tmux/session_navigation.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SelectWindowRequest","product":"core","slug":"tmux-selectwindowrequest"},{"id":"tmux.SelectWindowRequest.WindowID","name":"WindowID","kind":"attribute","modifiers":[],"parent":"tmux.SelectWindowRequest","signatures":[],"type":"WindowID","doc":{"summary":"WindowID selects a stable window linked into the receiver session."},"source":{"file":"tmux/session_navigation.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SelectWindowRequest.WindowID","product":"core","slug":"tmux-selectwindowrequest-windowid"},{"id":"tmux.SelectWindowRequest.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.SelectWindowRequest","signatures":[],"type":"*int","doc":{"summary":"Index selects a nonnegative winlink index in the receiver session."},"source":{"file":"tmux/session_navigation.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SelectWindowRequest.Index","product":"core","slug":"tmux-selectwindowrequest-index"},{"id":"tmux.Session.LastWindow","name":"LastWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"LastWindow makes the receiver session's previously selected winlink current and returns that freshly materialized session-specific [Window]. The selection is session-scoped; it does not promise focus for clients attached to other sessions. A transport or context error can be delivery-ambiguous and no rollback is attempted. Command or refresh failure returns a zero Window because this navigation operation cannot identify the selected view reliably without refresh."},"source":{"file":"tmux/session_navigation.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.LastWindow","product":"core","slug":"tmux-session-lastwindow"},{"id":"tmux.Session.NextWindow","name":"NextWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"NextWindow makes the next winlink current in the receiver session and returns that freshly materialized session-specific [Window]. The selection is session-scoped; it does not promise focus for clients attached to other sessions. A transport or context error can be delivery-ambiguous and no rollback is attempted. Command or refresh failure returns a zero Window."},"source":{"file":"tmux/session_navigation.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.NextWindow","product":"core","slug":"tmux-session-nextwindow"},{"id":"tmux.Session.PreviousWindow","name":"PreviousWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"PreviousWindow makes the previous winlink current in the receiver session and returns that freshly materialized session-specific [Window]. The selection is session-scoped; it does not promise focus for clients attached to other sessions. A transport or context error can be delivery-ambiguous and no rollback is attempted. Command or refresh failure returns a zero Window."},"source":{"file":"tmux/session_navigation.go","line":47,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.PreviousWindow","product":"core","slug":"tmux-session-previouswindow"},{"id":"tmux.Session.SelectWindow","name":"SelectWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SelectWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"SelectWindow makes one winlink current in the receiver session and returns that freshly materialized session-specific [Window]. WindowID is combined with the receiver SessionID, because a WindowID alone does not distinguish linked views. The selection is session-scoped; it does not promise focus for clients attached to other sessions.","body":"Command or refresh failures return zero because the selected view cannot be\nidentified without refresh. Transport errors are delivery-ambiguous."},"source":{"file":"tmux/session_navigation.go","line":59,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.SelectWindow","product":"core","slug":"tmux-session-selectwindow"},{"id":"tmux.RunOptions","name":"RunOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RunOptions configures [Session.Run] and [Session.Start]. Its zero value runs the command in a window tmux names, in the session's default directory and environment, and removes that window once the command has finished."},"source":{"file":"tmux/session_run.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunOptions","product":"core","slug":"tmux-runoptions"},{"id":"tmux.RunOptions.WindowName","name":"WindowName","kind":"attribute","modifiers":[],"parent":"tmux.RunOptions","signatures":[],"type":"string","doc":{"summary":"WindowName names the window the command runs in; empty lets tmux choose."},"source":{"file":"tmux/session_run.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunOptions.WindowName","product":"core","slug":"tmux-runoptions-windowname"},{"id":"tmux.RunOptions.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.RunOptions","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user; empty inherits the session's default."},"source":{"file":"tmux/session_run.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunOptions.StartDirectory","product":"core","slug":"tmux-runoptions-startdirectory"},{"id":"tmux.RunOptions.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.RunOptions","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is added to the command's environment. The map is not retained."},"source":{"file":"tmux/session_run.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunOptions.Environment","product":"core","slug":"tmux-runoptions-environment"},{"id":"tmux.RunOptions.Keep","name":"Keep","kind":"attribute","modifiers":[],"parent":"tmux.RunOptions","signatures":[],"type":"bool","doc":{"summary":"Keep leaves the finished window in place, showing what the command printed, instead of removing it."},"source":{"file":"tmux/session_run.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunOptions.Keep","product":"core","slug":"tmux-runoptions-keep"},{"id":"tmux.ErrOutcomeUnrecorded","name":"ErrOutcomeUnrecorded","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrOutcomeUnrecorded reports that a command's pane is dead while tmux has not recorded how the command ended, which it does by reaping the command's process. tmux is known to leave a pane in that state indefinitely, so this is reported rather than waited out, and rather than passed off as a zero exit status that would call a failed command successful."},"source":{"file":"tmux/session_run.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrOutcomeUnrecorded","product":"core","slug":"tmux-erroutcomeunrecorded"},{"id":"tmux.RunResult","name":"RunResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RunResult reports how a command finished and what its terminal showed."},"source":{"file":"tmux/session_run.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunResult","product":"core","slug":"tmux-runresult"},{"id":"tmux.RunResult.Status","name":"Status","kind":"attribute","modifiers":[],"parent":"tmux.RunResult","signatures":[],"type":"int","doc":{"summary":"Status is the command's exit status. It is zero when Signal is set."},"source":{"file":"tmux/session_run.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunResult.Status","product":"core","slug":"tmux-runresult-status"},{"id":"tmux.RunResult.Signal","name":"Signal","kind":"attribute","modifiers":[],"parent":"tmux.RunResult","signatures":[],"type":"string","doc":{"summary":"Signal names the signal that ended the command, when one did. It is empty before tmux 3.3, which reports no signal for a dead pane."},"source":{"file":"tmux/session_run.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunResult.Signal","product":"core","slug":"tmux-runresult-signal"},{"id":"tmux.RunResult.Lines","name":"Lines","kind":"attribute","modifiers":[],"parent":"tmux.RunResult","signatures":[],"type":"[]string","doc":{"summary":"Lines is what the terminal showed when the command finished, without the blank lines tmux pads a screen with."},"source":{"file":"tmux/session_run.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunResult.Lines","product":"core","slug":"tmux-runresult-lines"},{"id":"tmux.RunResult.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.RunResult","signatures":[],"type":"PaneID","doc":{"summary":"Pane is the pane the command ran in. It is live only when the run kept its window."},"source":{"file":"tmux/session_run.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RunResult.Pane","product":"core","slug":"tmux-runresult-pane"},{"id":"tmux.Session.Run","name":"Run","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"command","type":"string"},{"name":"options","type":"RunOptions"}],"returns":"(RunResult, error)"}],"doc":{"summary":"Run starts command in a new window of this session, waits for it to finish, and reports its exit status and what its terminal showed. It is [os/exec] for a program that needs a terminal: the command runs with a tty, so it sees isatty, colour, and a width, and what comes back is the screen tmux rendered rather than the bytes the program wrote.","body":"A nonzero status is a result, not an error; the error reports what tmux\ncould not do. The wait is tmux's own signal, backed by a liveness check that\nwidens from a quarter second in case that signal is lost: it needs no tmux\nbinary on the command's PATH and returns as the process exits. A command that never\nexits holds Run until ctx ends. On error, Run removes its window regardless\nof [RunOptions.Keep], since Run gives the caller no other chance to retry or\nclean up; a bare [Session.Start] followed by [Running.Wait] leaves that\nchoice to the caller instead. [Server.RunShell] runs a command with no pane\nat all."},"source":{"file":"tmux/session_run.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Run","product":"core","slug":"tmux-session-run"},{"id":"tmux.Session.Start","name":"Start","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"command","type":"string"},{"name":"options","type":"RunOptions"}],"returns":"(running *Running, err error)"}],"doc":{"summary":"Start runs command in a new window of this session and returns once it is under way, without waiting for it to finish. The returned [Running] reports the pane it runs in and blocks on demand: [Running.Wait] waits for the exit status and screen [Session.Run] would have returned, and [Running.Kill] stops the command. Options are exactly Run's.","body":"Before tmux 3.7, Start attempts to install an output pipe running cat\nunless the pane already has a pipe; a failed attempt only forfeits that\ncompatibility help. [Running.Wait] stops a pipe Start installed once the\noutcome is read, whether or not Keep leaves the window itself in place.\n\nIf Wait is never called, the window Start created is never removed."},"source":{"file":"tmux/session_run.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.Start","product":"core","slug":"tmux-session-start"},{"id":"tmux.Running","name":"Running","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Running is a command started by [Session.Start]: a real process, already under way, in a pane of its own. [Running.Pane] exposes that pane so its output can be streamed with [Pane.OpenObservation] or typed into with [Pane.Writer] while the command runs; [Running.Wait] and [Running.Kill] wait for and stop it. A line printed with nothing separating it from the command's own exit can race tmux's control-mode notification of it and never reach [PaneObservation.Reader]; [RunResult.Lines] from Wait, a plain screen capture rather than that notification stream, always has it."},"source":{"file":"tmux/session_run.go","line":192,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Running","product":"core","slug":"tmux-running"},{"id":"tmux.Running.Pane","name":"Pane","kind":"method","modifiers":[],"parent":"tmux.Running","signatures":[{"params":[],"returns":"Pane"}],"doc":{"summary":"Pane returns the pane the command runs in, materialized immediately after Start returned. Like any materialized record it does not refresh itself; a call after Wait or Kill may no longer describe a live pane."},"source":{"file":"tmux/session_run.go","line":218,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Running.Pane","product":"core","slug":"tmux-running-pane"},{"id":"tmux.Running.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"tmux.Running","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(RunResult, error)"}],"doc":{"summary":"Wait blocks until the command exits, on tmux's own wait-for signal backed by a widening liveness check, and reports its exit status and what its terminal showed. It removes the window Start created unless [RunOptions.Keep] was set. A command whose process tmux never reaps has no outcome to report, and Wait ends with [ErrOutcomeUnrecorded] rather than the zero status that would make a failed command look successful.","body":"Wait may be called more than once and concurrently; every call observes the\nsame completion. The outcome is read once, as soon as any call sees the\ncommand end, on a context no caller's cancellation reaches, because from\nthen on it belongs to every caller. A call whose context ends first reports\nthat context and leaves the window alone; a later call gets the outcome."},"source":{"file":"tmux/session_run.go","line":234,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Running.Wait","product":"core","slug":"tmux-running-wait"},{"id":"tmux.Running.StreamTo","name":"StreamTo","kind":"method","modifiers":[],"parent":"tmux.Running","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"destination","type":"io.Writer"}],"returns":"(RunResult, error)"}],"doc":{"summary":"StreamTo copies what the command prints into destination as it prints it and then reports how it ended, so following a command and collecting its outcome are one blocking call rather than a goroutine the caller writes. It returns exactly what [Running.Wait] returns and, like Wait, removes the window unless [RunOptions.Keep] was set. destination is written only by this call, so it needs no synchronization of its own, and [Running.Kill] may be called from another goroutine while it runs.","body":"The stream is what tmux pushed, which is not quite everything: output the\ncommand printed before StreamTo opened its observation may or may not be in\nit, and tmux can drop a line printed with nothing between it and the\ncommand's exit. [RunResult.Lines] is a screen capture rather than a\nnotification stream and remains the authoritative record of what the command\nshowed. Streaming needs a control client, which a [Connection]-bound value\ndoes not have, so it returns [ErrConnectionRequiresProcess] there; Wait alone\ndoes not."},"source":{"file":"tmux/session_run.go","line":540,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Running.StreamTo","product":"core","slug":"tmux-running-streamto"},{"id":"tmux.Running.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Running","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill asks the tmux server to send SIGKILL to the process group running the command. It does not wait for the process to stop; call Wait to observe the resulting status or signal.","body":"Kill runs through [Server.RunShell] with the pane as its target, so tmux\nresolves the process group id itself, at the moment it runs, on whatever\nhost the server is on, rather than trusting a process id this program read\nearlier. A pane that no longer exists makes that id resolve empty and Kill\na no-op; Kill reports only whether tmux could dispatch the request, not\nwhether a process still existed to receive it."},"source":{"file":"tmux/session_run.go","line":592,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Running.Kill","product":"core","slug":"tmux-running-kill"},{"id":"tmux.ErrMalformedSnapshot","name":"ErrMalformedSnapshot","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedSnapshot identifies invalid required fields in decoded rows. SnapshotDecodeError matches it through errors.Is."},"source":{"file":"tmux/snapshot.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrMalformedSnapshot","product":"core","slug":"tmux-errmalformedsnapshot"},{"id":"tmux.ErrSnapshotAmbiguous","name":"ErrSnapshotAmbiguous","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrSnapshotAmbiguous identifies a point lookup with multiple matching views. SnapshotLookupError matches it through errors.Is."},"source":{"file":"tmux/snapshot.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrSnapshotAmbiguous","product":"core","slug":"tmux-errsnapshotambiguous"},{"id":"tmux.SnapshotDecodeError","name":"SnapshotDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SnapshotDecodeError identifies one malformed decoded list row. It matches [ErrMalformedSnapshot] through errors.Is; callers can recover its redacted location fields with errors.As."},"source":{"file":"tmux/snapshot.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotDecodeError","product":"core","slug":"tmux-snapshotdecodeerror"},{"id":"tmux.SnapshotDecodeError.Object","name":"Object","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"string","doc":{"summary":"Object names the tmux object whose listing contained the record."},"source":{"file":"tmux/snapshot.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotDecodeError.Object","product":"core","slug":"tmux-snapshotdecodeerror-object"},{"id":"tmux.SnapshotDecodeError.Record","name":"Record","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"int","doc":{"summary":"Record is the one-based physical record number in that listing."},"source":{"file":"tmux/snapshot.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotDecodeError.Record","product":"core","slug":"tmux-snapshotdecodeerror-record"},{"id":"tmux.SnapshotDecodeError.Field","name":"Field","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"string","doc":{"summary":"Field names the required format field that could not be decoded."},"source":{"file":"tmux/snapshot.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotDecodeError.Field","product":"core","slug":"tmux-snapshotdecodeerror-field"},{"id":"tmux.SnapshotDecodeError.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"string","doc":{"summary":"Value is redacted for library-created errors because snapshot fields may contain pane output, commands, paths, or other caller data."},"source":{"file":"tmux/snapshot.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotDecodeError.Value","product":"core","slug":"tmux-snapshotdecodeerror-value"},{"id":"tmux.SnapshotDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes why the field was malformed."},"source":{"file":"tmux/snapshot.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotDecodeError.Reason","product":"core","slug":"tmux-snapshotdecodeerror-reason"},{"id":"tmux.SnapshotDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/snapshot.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotDecodeError.Error","product":"core","slug":"tmux-snapshotdecodeerror-error"},{"id":"tmux.SnapshotDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes SnapshotDecodeError compatible with ErrMalformedSnapshot."},"source":{"file":"tmux/snapshot.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotDecodeError.Unwrap","product":"core","slug":"tmux-snapshotdecodeerror-unwrap"},{"id":"tmux.SnapshotLookupError","name":"SnapshotLookupError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SnapshotLookupError reports the cardinality of an unsuccessful point lookup. It matches [ErrNotFound] or [ErrSnapshotAmbiguous] through errors.Is; callers can recover its target and count with errors.As."},"source":{"file":"tmux/snapshot.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotLookupError","product":"core","slug":"tmux-snapshotlookuperror"},{"id":"tmux.SnapshotLookupError.Object","name":"Object","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[],"type":"string","doc":{"summary":"Object names the requested snapshot object kind."},"source":{"file":"tmux/snapshot.go","line":58,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotLookupError.Object","product":"core","slug":"tmux-snapshotlookuperror-object"},{"id":"tmux.SnapshotLookupError.Identifier","name":"Identifier","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[],"type":"string","doc":{"summary":"Identifier is the requested stable identifier."},"source":{"file":"tmux/snapshot.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotLookupError.Identifier","product":"core","slug":"tmux-snapshotlookuperror-identifier"},{"id":"tmux.SnapshotLookupError.Matches","name":"Matches","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[],"type":"int","doc":{"summary":"Matches is the number of matching materialized views."},"source":{"file":"tmux/snapshot.go","line":62,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotLookupError.Matches","product":"core","slug":"tmux-snapshotlookuperror-matches"},{"id":"tmux.SnapshotLookupError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/snapshot.go","line":66,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotLookupError.Error","product":"core","slug":"tmux-snapshotlookuperror-error"},{"id":"tmux.SnapshotLookupError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap classifies the failed lookup by cardinality."},"source":{"file":"tmux/snapshot.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SnapshotLookupError.Unwrap","product":"core","slug":"tmux-snapshotlookuperror-unwrap"},{"id":"tmux.Snapshot","name":"Snapshot","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Snapshot is an immutable, observational view of one tmux server. It is normally returned by [Server.Snapshot]. Its zero value has a zero [Version], a zero [Server], non-nil empty collection slices, and not-found point lookups. Accessors never query tmux; returned slices are newly allocated and their contained records are shallow copies."},"source":{"file":"tmux/snapshot.go","line":92,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot","product":"core","slug":"tmux-snapshot"},{"id":"tmux.Snapshot.Version","name":"Version","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"Version"}],"doc":{"summary":"Version returns the tmux version that selected this snapshot's format fields. The zero Snapshot returns a zero Version."},"source":{"file":"tmux/snapshot.go","line":148,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.Version","product":"core","slug":"tmux-snapshot-version"},{"id":"tmux.Snapshot.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the configured handle that produced this snapshot. The zero Snapshot returns a zero Server."},"source":{"file":"tmux/snapshot.go","line":157,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.Server","product":"core","slug":"tmux-snapshot-server"},{"id":"tmux.Snapshot.Sessions","name":"Sessions","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"[]Session"}],"doc":{"summary":"Sessions returns a newly allocated shallow copy of materialized sessions. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":166,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.Sessions","product":"core","slug":"tmux-snapshot-sessions"},{"id":"tmux.Snapshot.Windows","name":"Windows","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"[]Window"}],"doc":{"summary":"Windows returns a newly allocated shallow copy with one view per winlink. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":175,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.Windows","product":"core","slug":"tmux-snapshot-windows"},{"id":"tmux.Snapshot.Panes","name":"Panes","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"[]Pane"}],"doc":{"summary":"Panes returns a newly allocated shallow copy of pane views for every winlink. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":184,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.Panes","product":"core","slug":"tmux-snapshot-panes"},{"id":"tmux.Snapshot.Clients","name":"Clients","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"[]Client"}],"doc":{"summary":"Clients returns a newly allocated shallow copy of materialized clients. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":193,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.Clients","product":"core","slug":"tmux-snapshot-clients"},{"id":"tmux.Snapshot.SessionsSeq","name":"SessionsSeq","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"iter.Seq[Session]"}],"doc":{"summary":"SessionsSeq returns an iterator over materialized session values. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":202,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.SessionsSeq","product":"core","slug":"tmux-snapshot-sessionsseq"},{"id":"tmux.Snapshot.WindowsSeq","name":"WindowsSeq","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"iter.Seq[Window]"}],"doc":{"summary":"WindowsSeq returns an iterator over materialized winlink values. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":211,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.WindowsSeq","product":"core","slug":"tmux-snapshot-windowsseq"},{"id":"tmux.Snapshot.PanesSeq","name":"PanesSeq","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"iter.Seq[Pane]"}],"doc":{"summary":"PanesSeq returns an iterator over materialized pane-view values. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":220,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.PanesSeq","product":"core","slug":"tmux-snapshot-panesseq"},{"id":"tmux.Snapshot.ClientsSeq","name":"ClientsSeq","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"iter.Seq[Client]"}],"doc":{"summary":"ClientsSeq returns an iterator over materialized client values. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":229,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.ClientsSeq","product":"core","slug":"tmux-snapshot-clientsseq"},{"id":"tmux.Snapshot.SessionByID","name":"SessionByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"SessionID"}],"returns":"(Session, error)"}],"doc":{"summary":"SessionByID returns the sole session view with id. It never queries tmux and returns a [SnapshotLookupError] matching [ErrNotFound] otherwise."},"source":{"file":"tmux/snapshot.go","line":238,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.SessionByID","product":"core","slug":"tmux-snapshot-sessionbyid"},{"id":"tmux.Snapshot.WindowByID","name":"WindowByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"WindowID"}],"returns":"(Window, error)"}],"doc":{"summary":"WindowByID returns the sole winlink view with id. Linked sessions can make an ID ambiguous, so it can return a [SnapshotLookupError] matching [ErrSnapshotAmbiguous]. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":248,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.WindowByID","product":"core","slug":"tmux-snapshot-windowbyid"},{"id":"tmux.Snapshot.WindowsByID","name":"WindowsByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"WindowID"}],"returns":"[]Window"}],"doc":{"summary":"WindowsByID returns newly allocated shallow copies of every winlink view with id. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":257,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.WindowsByID","product":"core","slug":"tmux-snapshot-windowsbyid"},{"id":"tmux.Snapshot.PaneByID","name":"PaneByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"PaneID"}],"returns":"(Pane, error)"}],"doc":{"summary":"PaneByID returns the sole pane view with id. Linked-session views can make an ID ambiguous, so it can return a [SnapshotLookupError] matching [ErrSnapshotAmbiguous]. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":267,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.PaneByID","product":"core","slug":"tmux-snapshot-panebyid"},{"id":"tmux.Snapshot.PanesByID","name":"PanesByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"PaneID"}],"returns":"[]Pane"}],"doc":{"summary":"PanesByID returns newly allocated shallow copies of every pane view with id. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":276,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.PanesByID","product":"core","slug":"tmux-snapshot-panesbyid"},{"id":"tmux.Snapshot.ClientByName","name":"ClientByName","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"name","type":"ClientName"}],"returns":"(Client, error)"}],"doc":{"summary":"ClientByName returns the sole client view with name. It never queries tmux and returns a [SnapshotLookupError] matching [ErrNotFound] or [ErrSnapshotAmbiguous] when cardinality is not one."},"source":{"file":"tmux/snapshot.go","line":286,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Snapshot.ClientByName","product":"core","slug":"tmux-snapshot-clientbyname"},{"id":"tmux.Server.Snapshot","name":"Snapshot","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Snapshot, error)"}],"doc":{"summary":"Snapshot materializes sessions, winlinks, panes, and clients. Its sequential commands produce an observationally consistent result, not an atomic transaction. Failures remain errors rather than empty snapshots; cancellation may occur after earlier listings completed.","body":"Identity probes reject a daemon replacement during subprocess collection.\nA connection is already bound to the exact daemon and skips the closing\nprobe; the opening probe still selects version-specific fields."},"source":{"file":"tmux/snapshot_capture.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.Snapshot","product":"core","slug":"tmux-server-snapshot"},{"id":"tmux.SocketSelection","name":"SocketSelection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SocketSelection describes the Unix filesystem endpoint selected by a [Server]. It does not report whether a server is listening there or whether tmux would accept the named-socket directory's ownership and permissions."},"source":{"file":"tmux/socket_selection.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SocketSelection","product":"core","slug":"tmux-socketselection"},{"id":"tmux.SocketSelection.Path","name":"Path","kind":"attribute","modifiers":[],"parent":"tmux.SocketSelection","signatures":[],"type":"string","doc":{"summary":"Path is the absolute path selected by the frozen socket options, environment, and working directory."},"source":{"file":"tmux/socket_selection.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SocketSelection.Path","product":"core","slug":"tmux-socketselection-path"},{"id":"tmux.SocketSelection.NamedDirectory","name":"NamedDirectory","kind":"attribute","modifiers":[],"parent":"tmux.SocketSelection","signatures":[],"type":"string","doc":{"summary":"NamedDirectory is the directory tmux uses for named and default sockets. It can differ from Path's directory when -S or TMUX selects another path."},"source":{"file":"tmux/socket_selection.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SocketSelection.NamedDirectory","product":"core","slug":"tmux-socketselection-nameddirectory"},{"id":"tmux.Server.SocketSelection","name":"SocketSelection","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"(SocketSelection, error)"}],"doc":{"summary":"SocketSelection returns tmux's -S, -L, TMUX, and default-socket precedence snapshotted by [NewServer]. It does not start tmux or require the selected socket to exist."},"source":{"file":"tmux/socket_selection.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Server.SocketSelection","product":"core","slug":"tmux-server-socketselection"},{"id":"tmux.ErrInvalidSparseIndex","name":"ErrInvalidSparseIndex","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidSparseIndex identifies a negative or overflowing sparse index."},"source":{"file":"tmux/sparse_array.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidSparseIndex","product":"core","slug":"tmux-errinvalidsparseindex"},{"id":"tmux.ErrDuplicateSparseIndex","name":"ErrDuplicateSparseIndex","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrDuplicateSparseIndex identifies repeated constructor indices."},"source":{"file":"tmux/sparse_array.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrDuplicateSparseIndex","product":"core","slug":"tmux-errduplicatesparseindex"},{"id":"tmux.SparseEntry","name":"SparseEntry","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SparseEntry is one indexed [SparseArray] value."},"source":{"file":"tmux/sparse_array.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseEntry","product":"core","slug":"tmux-sparseentry"},{"id":"tmux.SparseEntry.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.SparseEntry","signatures":[],"type":"int","doc":{"summary":"Index is the nonnegative sparse-array index."},"source":{"file":"tmux/sparse_array.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseEntry.Index","product":"core","slug":"tmux-sparseentry-index"},{"id":"tmux.SparseEntry.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.SparseEntry","signatures":[],"type":"T","doc":{"summary":"Value is the value stored at Index."},"source":{"file":"tmux/sparse_array.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseEntry.Value","product":"core","slug":"tmux-sparseentry-value"},{"id":"tmux.SparseArray","name":"SparseArray","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SparseArray stores values at sorted, nonnegative indices. Its zero value is an empty array. Constructors and functional updates own their entry slices; copies of reference-bearing T values remain shallow."},"source":{"file":"tmux/sparse_array.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray","product":"core","slug":"tmux-sparsearray"},{"id":"tmux.NewSparseArray","name":"NewSparseArray","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"entries","type":"SparseEntry[T]"}],"returns":"(SparseArray[T], error)","typeParams":["T any"]}],"doc":{"summary":"NewSparseArray builds an array from entries, sorting them by index. It returns errors matching [ErrInvalidSparseIndex] or [ErrDuplicateSparseIndex] for negative, overflowing, or duplicate indices."},"source":{"file":"tmux/sparse_array.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewSparseArray","product":"core","slug":"tmux-newsparsearray"},{"id":"tmux.SparseArray.Get","name":"Get","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[{"name":"index","type":"int"}],"returns":"(T, bool)"}],"doc":{"summary":"Get returns the value at index and reports whether it is present. A missing index, including a sparse hole, returns the zero value and false."},"source":{"file":"tmux/sparse_array.go","line":66,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray.Get","product":"core","slug":"tmux-sparsearray-get"},{"id":"tmux.SparseArray.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of present entries, not the highest index."},"source":{"file":"tmux/sparse_array.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray.Len","product":"core","slug":"tmux-sparsearray-len"},{"id":"tmux.SparseArray.Indices","name":"Indices","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"[]int"}],"doc":{"summary":"Indices returns a fresh slice of present indices in ascending order."},"source":{"file":"tmux/sparse_array.go","line":81,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray.Indices","product":"core","slug":"tmux-sparsearray-indices"},{"id":"tmux.SparseArray.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"[]SparseEntry[T]"}],"doc":{"summary":"Entries returns a fresh shallow copy in ascending index order."},"source":{"file":"tmux/sparse_array.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray.Entries","product":"core","slug":"tmux-sparsearray-entries"},{"id":"tmux.SparseArray.Values","name":"Values","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"[]T"}],"doc":{"summary":"Values returns a fresh shallow slice in ascending index order."},"source":{"file":"tmux/sparse_array.go","line":95,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray.Values","product":"core","slug":"tmux-sparsearray-values"},{"id":"tmux.SparseArray.All","name":"All","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"iter.Seq2[int, T]"}],"doc":{"summary":"All returns an iterator over indices and values in ascending index order."},"source":{"file":"tmux/sparse_array.go","line":104,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray.All","product":"core","slug":"tmux-sparsearray-all"},{"id":"tmux.SparseArray.With","name":"With","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[{"name":"index","type":"int"},{"name":"value","type":"T"}],"returns":"(SparseArray[T], error)"}],"doc":{"summary":"With returns a copy with value inserted or replaced at index. It leaves the receiver unchanged and returns an error matching [ErrInvalidSparseIndex] for a negative index."},"source":{"file":"tmux/sparse_array.go","line":117,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray.With","product":"core","slug":"tmux-sparsearray-with"},{"id":"tmux.SparseArray.Append","name":"Append","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[{"name":"value","type":"T"}],"returns":"(SparseArray[T], error)"}],"doc":{"summary":"Append returns a copy with value stored after the highest present index. It leaves the receiver unchanged and returns an error matching [ErrInvalidSparseIndex] when that index overflows."},"source":{"file":"tmux/sparse_array.go","line":136,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SparseArray.Append","product":"core","slug":"tmux-sparsearray-append"},{"id":"tmux.ErrMissingTarget","name":"ErrMissingTarget","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMissingTarget identifies an operation on a zero-value model identity."},"source":{"file":"tmux/target.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrMissingTarget","product":"core","slug":"tmux-errmissingtarget"},{"id":"tmux.ErrInvalidTarget","name":"ErrInvalidTarget","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidTarget identifies a malformed stable tmux identifier. It is matched by errors.Is for TargetError."},"source":{"file":"tmux/target.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidTarget","product":"core","slug":"tmux-errinvalidtarget"},{"id":"tmux.TargetError","name":"TargetError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TargetError reports a malformed stable identifier before command execution. It matches [ErrInvalidTarget] through errors.Is; callers can recover Object and Target with errors.As."},"source":{"file":"tmux/target.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TargetError","product":"core","slug":"tmux-targeterror"},{"id":"tmux.TargetError.Object","name":"Object","kind":"attribute","modifiers":[],"parent":"tmux.TargetError","signatures":[],"type":"string","doc":{"summary":"Object names the tmux object kind whose target was validated."},"source":{"file":"tmux/target.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TargetError.Object","product":"core","slug":"tmux-targeterror-object"},{"id":"tmux.TargetError.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.TargetError","signatures":[],"type":"string","doc":{"summary":"Target is the submitted target text."},"source":{"file":"tmux/target.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TargetError.Target","product":"core","slug":"tmux-targeterror-target"},{"id":"tmux.TargetError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.TargetError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/target.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TargetError.Error","product":"core","slug":"tmux-targeterror-error"},{"id":"tmux.TargetError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.TargetError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes TargetError compatible with ErrInvalidTarget."},"source":{"file":"tmux/target.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.TargetError.Unwrap","product":"core","slug":"tmux-targeterror-unwrap"},{"id":"tmux.MissingTargetError","name":"MissingTargetError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MissingTargetError reports an operation attempted on a zero-value model identity. It matches [ErrMissingTarget] through errors.Is; callers can recover Object with errors.As.","body":"A relation accessor such as [Session.ActiveWindow] or [Session.Windows]\nreturns ok false rather than a value with no id, and a creation call such\nas [Server.NewSession] carries no relations at all - so using a discarded\nor freshly created value's zero-value fields reaches this error on the\nfirst operation. Resolve live state with a Resolve* method or a fresh\n[Server.Snapshot] instead."},"source":{"file":"tmux/target.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MissingTargetError","product":"core","slug":"tmux-missingtargeterror"},{"id":"tmux.MissingTargetError.Object","name":"Object","kind":"attribute","modifiers":[],"parent":"tmux.MissingTargetError","signatures":[],"type":"string","doc":{"summary":"Object names the tmux object kind with no id: \"session\", \"window\", \"pane\", or \"client\"."},"source":{"file":"tmux/target.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MissingTargetError.Object","product":"core","slug":"tmux-missingtargeterror-object"},{"id":"tmux.MissingTargetError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.MissingTargetError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/target.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MissingTargetError.Error","product":"core","slug":"tmux-missingtargeterror-error"},{"id":"tmux.MissingTargetError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.MissingTargetError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes MissingTargetError compatible with ErrMissingTarget."},"source":{"file":"tmux/target.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MissingTargetError.Unwrap","product":"core","slug":"tmux-missingtargeterror-unwrap"},{"id":"tmux.MinimumSupportedVersion","name":"MinimumSupportedVersion","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"MinimumSupportedVersion is the oldest tmux feature level supported by this package."},"source":{"file":"tmux/version.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MinimumSupportedVersion","product":"core","slug":"tmux-minimumsupportedversion"},{"id":"tmux.MinimumConnectionVersion","name":"MinimumConnectionVersion","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"MinimumConnectionVersion is the oldest tmux feature level that supports terminal Connection ownership. Later releases may strengthen individual lifecycle guarantees without changing this floor."},"source":{"file":"tmux/version.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MinimumConnectionVersion","product":"core","slug":"tmux-minimumconnectionversion"},{"id":"tmux.MaximumTestedVersion","name":"MaximumTestedVersion","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"MaximumTestedVersion is the newest numbered tmux feature level covered by this package's tests. The matrix also runs 3.8-rc, which is a release candidate rather than a numbered feature level, so it does not raise this."},"source":{"file":"tmux/version.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MaximumTestedVersion","product":"core","slug":"tmux-maximumtestedversion"},{"id":"tmux.ErrInvalidVersion","name":"ErrInvalidVersion","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidVersion identifies malformed tmux version tokens. It is matched by errors.Is for VersionError."},"source":{"file":"tmux/version.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ErrInvalidVersion","product":"core","slug":"tmux-errinvalidversion"},{"id":"tmux.VersionError","name":"VersionError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VersionError reports a tmux version token that cannot be parsed. It matches [ErrInvalidVersion] through errors.Is; callers can recover Token with errors.As."},"source":{"file":"tmux/version.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionError","product":"core","slug":"tmux-versionerror"},{"id":"tmux.VersionError.Token","name":"Token","kind":"attribute","modifiers":[],"parent":"tmux.VersionError","signatures":[],"type":"string","doc":{"summary":"Token is the rejected tmux version text."},"source":{"file":"tmux/version.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionError.Token","product":"core","slug":"tmux-versionerror-token"},{"id":"tmux.VersionError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.VersionError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/version.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionError.Error","product":"core","slug":"tmux-versionerror-error"},{"id":"tmux.VersionError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.VersionError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes VersionError compatible with ErrInvalidVersion."},"source":{"file":"tmux/version.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.VersionError.Unwrap","product":"core","slug":"tmux-versionerror-unwrap"},{"id":"tmux.Version","name":"Version","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Version is a parsed tmux version that preserves its original token. Obtain a value with [ParseVersion], [Server.Version], or [Snapshot.Version]. Its zero value has no feature level and is useful only as an absent version. Parsed OpenBSD base-system tokens also have no feature level until [Server.Version] probes the configured binary's commands."},"source":{"file":"tmux/version.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Version","product":"core","slug":"tmux-version"},{"id":"tmux.ParseVersion","name":"ParseVersion","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"raw","type":"string"}],"returns":"(Version, error)"}],"doc":{"summary":"ParseVersion parses a raw tmux version token. It returns a [VersionError] matching [ErrInvalidVersion] when the token cannot be parsed."},"source":{"file":"tmux/version.go","line":73,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ParseVersion","product":"core","slug":"tmux-parseversion"},{"id":"tmux.Version.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the original tmux version token."},"source":{"file":"tmux/version.go","line":136,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Version.String","product":"core","slug":"tmux-version-string"},{"id":"tmux.Version.Major","name":"Major","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Major returns the capability-level major component. Development tokens use the latest tested feature core. Unprobed OpenBSD base-system tokens return zero."},"source":{"file":"tmux/version.go","line":143,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Version.Major","product":"core","slug":"tmux-version-major"},{"id":"tmux.Version.Minor","name":"Minor","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Minor returns the capability-level minor component, or zero when absent. Development tokens use the latest tested feature core. Unprobed OpenBSD base-system tokens return zero."},"source":{"file":"tmux/version.go","line":150,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Version.Minor","product":"core","slug":"tmux-version-minor"},{"id":"tmux.Version.Patch","name":"Patch","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Patch returns the capability-level patch component, or zero when absent."},"source":{"file":"tmux/version.go","line":155,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Version.Patch","product":"core","slug":"tmux-version-patch"},{"id":"tmux.Version.Compare","name":"Compare","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[{"name":"other","type":"Version"}],"returns":"int"}],"doc":{"summary":"Compare compares numeric feature levels and returns -1, 0, or 1. Release qualifiers other than master do not change the feature level."},"source":{"file":"tmux/version.go","line":161,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Version.Compare","product":"core","slug":"tmux-version-compare"},{"id":"tmux.Version.CompareRelease","name":"CompareRelease","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[{"name":"other","type":"Version"}],"returns":"int"}],"doc":{"summary":"CompareRelease compares raw release suffixes using libtmux's legacy order. Use Compare for feature gates, where point-release suffixes intentionally share one capability level."},"source":{"file":"tmux/version.go","line":178,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Version.CompareRelease","product":"core","slug":"tmux-version-comparerelease"},{"id":"tmux.Version.AtLeast","name":"AtLeast","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[{"name":"minimum","type":"Version"}],"returns":"bool"}],"doc":{"summary":"AtLeast reports whether v provides the same or a newer feature level."},"source":{"file":"tmux/version.go","line":234,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Version.AtLeast","product":"core","slug":"tmux-version-atleast"},{"id":"tmux.UnsupportedPolicy","name":"UnsupportedPolicy","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"UnsupportedPolicy selects what a request does when it needs an optional tmux capability the running server does not have.","body":"The default refuses because dropping a flag can change behavior while still\nreturning success.\n\nChoose degradation only when omission is acceptable:\n\nserver, err := tmux.NewServer(tmux.ServerOptions{\n\tUnsupported:    tmux.DegradeUnsupported,\n\tWarningHandler: func(w tmux.Warning) { log.Printf(\"tmux: %s\", w) },\n})\nif err != nil {\n\tlog.Fatal(err)\n}\n\nSet [ServerOptions.WarningHandler] alongside it to observe omissions."},"source":{"file":"tmux/warning.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnsupportedPolicy","product":"core","slug":"tmux-unsupportedpolicy"},{"id":"tmux.FailUnsupported","name":"FailUnsupported","kind":"constant","modifiers":[],"signatures":[],"type":"UnsupportedPolicy","doc":{"summary":"FailUnsupported refuses a request naming a capability the running tmux does not have, with a VersionTooLowError naming the subcommand and the capability. It is the zero value."},"source":{"file":"tmux/warning.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.FailUnsupported","product":"core","slug":"tmux-failunsupported"},{"id":"tmux.DegradeUnsupported","name":"DegradeUnsupported","kind":"constant","modifiers":[],"signatures":[],"type":"UnsupportedPolicy","doc":{"summary":"DegradeUnsupported omits the capability, runs the reduced command, and reports the decision to ServerOptions.WarningHandler as a WarningUnsupportedFeature."},"source":{"file":"tmux/warning.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.DegradeUnsupported","product":"core","slug":"tmux-degradeunsupported"},{"id":"tmux.UnsupportedPolicy.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.UnsupportedPolicy","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer."},"source":{"file":"tmux/warning.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnsupportedPolicy.String","product":"core","slug":"tmux-unsupportedpolicy-string"},{"id":"tmux.WarningKind","name":"WarningKind","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WarningKind identifies one closed class of nonfatal library warning."},"source":{"file":"tmux/warning.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WarningKind","product":"core","slug":"tmux-warningkind"},{"id":"tmux.WarningUnsupportedFeature","name":"WarningUnsupportedFeature","kind":"constant","modifiers":[],"signatures":[],"type":"WarningKind","doc":{"summary":"WarningUnsupportedFeature reports a requested feature omitted because the connected tmux binary is too old."},"source":{"file":"tmux/warning.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WarningUnsupportedFeature","product":"core","slug":"tmux-warningunsupportedfeature"},{"id":"tmux.WarningCommandStderr","name":"WarningCommandStderr","kind":"constant","modifiers":[],"signatures":[],"type":"WarningKind","doc":{"summary":"WarningCommandStderr reports stderr from a completed command whose Python API treats the diagnostic as nonfatal."},"source":{"file":"tmux/warning.go","line":60,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WarningCommandStderr","product":"core","slug":"tmux-warningcommandstderr"},{"id":"tmux.Warning","name":"Warning","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Warning describes one nonfatal compatibility decision delivered to a [WarningHandler]."},"source":{"file":"tmux/warning.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Warning","product":"core","slug":"tmux-warning"},{"id":"tmux.Warning.Kind","name":"Kind","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"WarningKind","doc":{"summary":"Kind classifies the compatibility decision."},"source":{"file":"tmux/warning.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Warning.Kind","product":"core","slug":"tmux-warning-kind"},{"id":"tmux.Warning.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"string","doc":{"summary":"Subcommand names the tmux subcommand affected by the decision."},"source":{"file":"tmux/warning.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Warning.Subcommand","product":"core","slug":"tmux-warning-subcommand"},{"id":"tmux.Warning.Feature","name":"Feature","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"string","doc":{"summary":"Feature names the optional tmux capability involved."},"source":{"file":"tmux/warning.go","line":71,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Warning.Feature","product":"core","slug":"tmux-warning-feature"},{"id":"tmux.Warning.CurrentVersion","name":"CurrentVersion","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"Version","doc":{"summary":"CurrentVersion is the observed tmux version."},"source":{"file":"tmux/warning.go","line":73,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Warning.CurrentVersion","product":"core","slug":"tmux-warning-currentversion"},{"id":"tmux.Warning.RequiredVersion","name":"RequiredVersion","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"Version","doc":{"summary":"RequiredVersion is the minimum tmux version for Feature."},"source":{"file":"tmux/warning.go","line":75,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Warning.RequiredVersion","product":"core","slug":"tmux-warning-requiredversion"},{"id":"tmux.Warning.Message","name":"Message","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"string","doc":{"summary":"Message describes the nonfatal compatibility decision."},"source":{"file":"tmux/warning.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Warning.Message","product":"core","slug":"tmux-warning-message"},{"id":"tmux.WarningHandler","name":"WarningHandler","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WarningHandler receives warnings synchronously on the caller goroutine:","body":"server, err := tmux.NewServer(tmux.ServerOptions{\n\tWarningHandler: func(warning tmux.Warning) {\n\t\tlog.Printf(\"tmux: %s\", warning.Message)\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\n\nOperations may invoke it concurrently; synchronize shared state. Diagnostics\nmay contain caller-supplied arguments and are delivered only to this handler."},"source":{"file":"tmux/warning.go","line":93,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WarningHandler","product":"core","slug":"tmux-warninghandler"},{"id":"tmux.Warning.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Warning","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer by returning Message."},"source":{"file":"tmux/warning.go","line":96,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Warning.String","product":"core","slug":"tmux-warning-string"},{"id":"tmux.SelectLayoutRequest","name":"SelectLayoutRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SelectLayoutRequest selects one layout operation. Its zero value reapplies the last preset layout. Layout, Spread, Next, and Previous are mutually exclusive and are validated before execution; an empty Layout is omitted rather than passed explicitly. The request contains no retained caller-owned storage and is supported on tmux 3.2a or later."},"source":{"file":"tmux/window_layout.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SelectLayoutRequest","product":"core","slug":"tmux-selectlayoutrequest"},{"id":"tmux.SelectLayoutRequest.Layout","name":"Layout","kind":"attribute","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[],"type":"string","doc":{"summary":"Layout names a preset or supplies a tmux layout string - either the classic checksum-prefixed grammar every supported version accepts, or the JSON shape tmux 3.8+ also accepts, exactly as #{window_layout} reported it; empty selects the zero-value behavior."},"source":{"file":"tmux/window_layout.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SelectLayoutRequest.Layout","product":"core","slug":"tmux-selectlayoutrequest-layout"},{"id":"tmux.SelectLayoutRequest.Spread","name":"Spread","kind":"attribute","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[],"type":"bool","doc":{"summary":"Spread distributes pane space evenly."},"source":{"file":"tmux/window_layout.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SelectLayoutRequest.Spread","product":"core","slug":"tmux-selectlayoutrequest-spread"},{"id":"tmux.SelectLayoutRequest.Next","name":"Next","kind":"attribute","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[],"type":"bool","doc":{"summary":"Next selects the next preset layout."},"source":{"file":"tmux/window_layout.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SelectLayoutRequest.Next","product":"core","slug":"tmux-selectlayoutrequest-next"},{"id":"tmux.SelectLayoutRequest.Previous","name":"Previous","kind":"attribute","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[],"type":"bool","doc":{"summary":"Previous selects the previous preset layout."},"source":{"file":"tmux/window_layout.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SelectLayoutRequest.Previous","product":"core","slug":"tmux-selectlayoutrequest-previous"},{"id":"tmux.Window.SelectLayout","name":"SelectLayout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SelectLayoutRequest"}],"returns":"error"}],"doc":{"summary":"SelectLayout applies one layout operation to the receiver's exact winlink. It changes pane geometry without selecting the window or promising client focus. The materialized receiver is not refreshed, so callers that need current pane geometry must obtain a new snapshot or refresh related models. A transport or context error can be delivery-ambiguous; the void result cannot carry partial state and no rollback is attempted."},"source":{"file":"tmux/window_layout.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SelectLayout","product":"core","slug":"tmux-window-selectlayout"},{"id":"tmux.Window.NextLayout","name":"NextLayout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"NextLayout applies the next preset layout to the receiver's exact winlink. It changes pane geometry without selecting or refreshing the window. A transport or context error can be delivery-ambiguous; the void result cannot carry partial state and no rollback is attempted."},"source":{"file":"tmux/window_layout.go","line":299,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.NextLayout","product":"core","slug":"tmux-window-nextlayout"},{"id":"tmux.Window.PreviousLayout","name":"PreviousLayout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"PreviousLayout applies the previous preset layout to the receiver's exact winlink. It changes pane geometry without selecting or refreshing the window. A transport or context error can be delivery-ambiguous; the void result cannot carry partial state and no rollback is attempted."},"source":{"file":"tmux/window_layout.go","line":316,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.PreviousLayout","product":"core","slug":"tmux-window-previouslayout"},{"id":"tmux.NewWindowRequest","name":"NewWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NewWindowRequest configures window creation on tmux 3.2a or later. Its zero value uses inherited defaults; placement behavior depends on the receiver. [Session.NewWindow] uses tmux's next free index. [Window.NewWindow] instead targets the receiver's occupied index and normally returns a command error; KillExisting may replace it. [Window.NewWindow] rejects Index. SelectExisting may run name-expansion probes before creation.","body":"Pointer fields are explicit when nonnil. Methods copy them and Environment\nbefore I/O; concurrent mutation during the copy is unsafe."},"source":{"file":"tmux/window_lifecycle.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest","product":"core","slug":"tmux-newwindowrequest"},{"id":"tmux.NewWindowRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"*string","doc":{"summary":"Name is omitted when nil. A nonnil empty string remains an explicit -n operand. The value is copied before tmux is called."},"source":{"file":"tmux/window_lifecycle.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.Name","product":"core","slug":"tmux-newwindowrequest-name"},{"id":"tmux.NewWindowRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets the created or selected winlink become current in the target session; false preserves its current window."},"source":{"file":"tmux/window_lifecycle.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.Attach","product":"core","slug":"tmux-newwindowrequest-attach"},{"id":"tmux.NewWindowRequest.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"*int","doc":{"summary":"Index selects an explicit nonnegative winlink index for Session.NewWindow; nil uses the next free index."},"source":{"file":"tmux/window_lifecycle.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.Index","product":"core","slug":"tmux-newwindowrequest-index"},{"id":"tmux.NewWindowRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Named-user forms such as ~other are rejected; empty inherits tmux's default."},"source":{"file":"tmux/window_lifecycle.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.StartDirectory","product":"core","slug":"tmux-newwindowrequest-startdirectory"},{"id":"tmux.NewWindowRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"string","doc":{"summary":"Command starts the window with this shell command; empty uses tmux's default command."},"source":{"file":"tmux/window_lifecycle.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.Command","product":"core","slug":"tmux-newwindowrequest-command"},{"id":"tmux.NewWindowRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order. The map is not retained; nil and an empty map both add no entries."},"source":{"file":"tmux/window_lifecycle.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.Environment","product":"core","slug":"tmux-newwindowrequest-environment"},{"id":"tmux.NewWindowRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"NewWindowDirection","doc":{"summary":"Direction places the new winlink relative to the target. Its zero value uses tmux's next free index with Session.NewWindow when Index is nil, but keeps Window.NewWindow on the receiver's occupied target. Use NewWindowDirectionAfter or NewWindowDirectionBefore for non-destructive relative creation through Window.NewWindow."},"source":{"file":"tmux/window_lifecycle.go","line":44,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.Direction","product":"core","slug":"tmux-newwindowrequest-direction"},{"id":"tmux.NewWindowRequest.KillExisting","name":"KillExisting","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KillExisting asks tmux to destroy a window occupying the target index."},"source":{"file":"tmux/window_lifecycle.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.KillExisting","product":"core","slug":"tmux-newwindowrequest-killexisting"},{"id":"tmux.NewWindowRequest.SelectExisting","name":"SelectExisting","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"bool","doc":{"summary":"SelectExisting asks tmux to select an existing expanded-name match instead of creating another window. It requires Name."},"source":{"file":"tmux/window_lifecycle.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowRequest.SelectExisting","product":"core","slug":"tmux-newwindowrequest-selectexisting"},{"id":"tmux.NewWindowDirection","name":"NewWindowDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NewWindowDirection selects placement relative to the target winlink on tmux 3.2a or later. Its zero value lets [Session.NewWindow] with nil Index use the next free index, while [Window.NewWindow] keeps the receiver's exact occupied target."},"source":{"file":"tmux/window_lifecycle.go","line":56,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowDirection","product":"core","slug":"tmux-newwindowdirection"},{"id":"tmux.NewWindowDirectionDefault","name":"NewWindowDirectionDefault","kind":"constant","modifiers":[],"signatures":[],"type":"NewWindowDirection","doc":{"summary":"NewWindowDirectionDefault uses the next free index with Session.NewWindow when Index is nil; Window.NewWindow instead keeps the receiver's exact occupied target."},"source":{"file":"tmux/window_lifecycle.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowDirectionDefault","product":"core","slug":"tmux-newwindowdirectiondefault"},{"id":"tmux.NewWindowDirectionAfter","name":"NewWindowDirectionAfter","kind":"constant","modifiers":[],"signatures":[],"type":"NewWindowDirection","doc":{"summary":"NewWindowDirectionAfter places the new winlink after the target."},"source":{"file":"tmux/window_lifecycle.go","line":65,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowDirectionAfter","product":"core","slug":"tmux-newwindowdirectionafter"},{"id":"tmux.NewWindowDirectionBefore","name":"NewWindowDirectionBefore","kind":"constant","modifiers":[],"signatures":[],"type":"NewWindowDirection","doc":{"summary":"NewWindowDirectionBefore places the new winlink before the target."},"source":{"file":"tmux/window_lifecycle.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.NewWindowDirectionBefore","product":"core","slug":"tmux-newwindowdirectionbefore"},{"id":"tmux.Session.NewWindow","name":"NewWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"NewWindow creates a winlink in the receiver session. Attach selects it as that session's current window; it is not a guarantee about clients attached to other sessions. The returned [Window] is freshly materialized in the receiver's exact session context, including when its stable [WindowID] is linked elsewhere.","body":"SelectExisting no-output recovery is available only when Index is nil. It\nexpands Name with tmux's version-specific rules and requires exactly one\nmatching window name in the receiver session. An explicit Index has no such\nrecovery. If tmux reports a WindowID before a transport or refresh failure,\nthe partial result contains that ID and the receiver SessionID with Index -1.\nOther failures return zero; creation is not rolled back."},"source":{"file":"tmux/window_lifecycle.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Session.NewWindow","product":"core","slug":"tmux-session-newwindow"},{"id":"tmux.Window.NewWindow","name":"NewWindow","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"NewWindow creates a window relative to the receiver's exact winlink. Set Direction to [NewWindowDirectionAfter] or [NewWindowDirectionBefore] for non-destructive relative creation. With the zero Direction, tmux targets the receiver's occupied index and normally returns a command error; KillExisting can destroy and replace that target. Attach changes the current window only in that target session. Index is rejected before execution because the receiver already supplies the target position. On tmux 3.8 and later, SelectExisting's -S also matches the receiver's own exact target (extended there to match -t as well as a window's name), so it always selects the receiver itself and prints nothing; the identity is already known without a probe. Earlier tmux only matched -S by name here, and always printed a created WindowID because the exact-target form never carries a bare name to match against.","body":"If tmux reports an ID before a transport or refresh failure, the partial result\ncontains it and the receiver SessionID with Index -1. Other failures return\nzero; creation is not rolled back."},"source":{"file":"tmux/window_lifecycle.go","line":108,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.NewWindow","product":"core","slug":"tmux-window-newwindow"},{"id":"tmux.Window.Rename","name":"Rename","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(Window, error)"}],"doc":{"summary":"Rename changes the stable window through the receiver's exact winlink and returns a canonical freshly materialized [Window]. The returned winlink may therefore use another session when the WindowID is linked. If the command succeeds but refresh fails, Rename returns the receiver with that error. A transport or context error can be delivery-ambiguous; no rollback is attempted."},"source":{"file":"tmux/window_lifecycle.go","line":348,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Rename","product":"core","slug":"tmux-window-rename"},{"id":"tmux.Window.Select","name":"Select","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"Select makes the receiver's exact winlink current in its session. It does not promise focus for clients attached to other sessions. Select returns a canonical freshly materialized [Window], which may use another linked session for the same WindowID. If the command succeeds but refresh fails, it returns the receiver with that error. A transport or context error can be delivery-ambiguous; no rollback is attempted."},"source":{"file":"tmux/window_lifecycle.go","line":377,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Select","product":"core","slug":"tmux-window-select"},{"id":"tmux.LinkWindowRequest","name":"LinkWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"LinkWindowRequest configures linking a window into another session on tmux 3.2a or later. Its zero value is invalid because TargetSession is required. Nil TargetIndex asks tmux for a destination index; a nonnil value is explicit and must be nonnegative. After and Before are mutually exclusive and are rejected before execution. TargetIndex is read during the call and is not retained; callers must not mutate it concurrently."},"source":{"file":"tmux/window_link_move.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LinkWindowRequest","product":"core","slug":"tmux-linkwindowrequest"},{"id":"tmux.LinkWindowRequest.TargetSession","name":"TargetSession","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"SessionID","doc":{"summary":"TargetSession identifies the destination session in the receiver's tmux server."},"source":{"file":"tmux/window_link_move.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LinkWindowRequest.TargetSession","product":"core","slug":"tmux-linkwindowrequest-targetsession"},{"id":"tmux.LinkWindowRequest.TargetIndex","name":"TargetIndex","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"*int","doc":{"summary":"TargetIndex selects a destination winlink index; nil lets tmux choose."},"source":{"file":"tmux/window_link_move.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LinkWindowRequest.TargetIndex","product":"core","slug":"tmux-linkwindowrequest-targetindex"},{"id":"tmux.LinkWindowRequest.KillExisting","name":"KillExisting","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KillExisting destroys a window already occupying the destination."},"source":{"file":"tmux/window_link_move.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LinkWindowRequest.KillExisting","product":"core","slug":"tmux-linkwindowrequest-killexisting"},{"id":"tmux.LinkWindowRequest.After","name":"After","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"After inserts the new winlink after the destination target."},"source":{"file":"tmux/window_link_move.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LinkWindowRequest.After","product":"core","slug":"tmux-linkwindowrequest-after"},{"id":"tmux.LinkWindowRequest.Before","name":"Before","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Before inserts the new winlink before the destination target."},"source":{"file":"tmux/window_link_move.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LinkWindowRequest.Before","product":"core","slug":"tmux-linkwindowrequest-before"},{"id":"tmux.LinkWindowRequest.Detach","name":"Detach","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Detach leaves the target session's current window unchanged."},"source":{"file":"tmux/window_link_move.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LinkWindowRequest.Detach","product":"core","slug":"tmux-linkwindowrequest-detach"},{"id":"tmux.UnlinkWindowRequest","name":"UnlinkWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"UnlinkWindowRequest configures unlinking one exact winlink on tmux 3.2a or later. Its zero value removes the link only when the stable window has another link. The request contains no retained caller-owned storage and has no invalid field combinations."},"source":{"file":"tmux/window_link_move.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnlinkWindowRequest","product":"core","slug":"tmux-unlinkwindowrequest"},{"id":"tmux.UnlinkWindowRequest.KillIfLast","name":"KillIfLast","kind":"attribute","modifiers":[],"parent":"tmux.UnlinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KillIfLast permits unlinking and destroying a stable window with no other links."},"source":{"file":"tmux/window_link_move.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.UnlinkWindowRequest.KillIfLast","product":"core","slug":"tmux-unlinkwindowrequest-killiflast"},{"id":"tmux.MoveWindowRequest","name":"MoveWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MoveWindowRequest configures moving one exact winlink on tmux 3.2a or later. Its zero value moves the receiver within its current session to a tmux-chosen index and lets the moved winlink become current. Nil TargetIndex asks tmux for that index; a nonnil value is explicit and must be nonnegative. After and Before are mutually exclusive. Renumber is a standalone mode mutually exclusive with TargetIndex, After, Before, NoSelect, and KillTarget. Invalid combinations are rejected before execution. TargetIndex is read during the call and is not retained; callers must not mutate it concurrently."},"source":{"file":"tmux/window_link_move.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MoveWindowRequest","product":"core","slug":"tmux-movewindowrequest"},{"id":"tmux.MoveWindowRequest.TargetSession","name":"TargetSession","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"SessionID","doc":{"summary":"TargetSession identifies the destination session; zero uses the receiver session."},"source":{"file":"tmux/window_link_move.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MoveWindowRequest.TargetSession","product":"core","slug":"tmux-movewindowrequest-targetsession"},{"id":"tmux.MoveWindowRequest.TargetIndex","name":"TargetIndex","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"*int","doc":{"summary":"TargetIndex selects a destination winlink index; nil lets tmux choose."},"source":{"file":"tmux/window_link_move.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MoveWindowRequest.TargetIndex","product":"core","slug":"tmux-movewindowrequest-targetindex"},{"id":"tmux.MoveWindowRequest.After","name":"After","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"After inserts the moved winlink after the destination target."},"source":{"file":"tmux/window_link_move.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MoveWindowRequest.After","product":"core","slug":"tmux-movewindowrequest-after"},{"id":"tmux.MoveWindowRequest.Before","name":"Before","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Before inserts the moved winlink before the destination target."},"source":{"file":"tmux/window_link_move.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MoveWindowRequest.Before","product":"core","slug":"tmux-movewindowrequest-before"},{"id":"tmux.MoveWindowRequest.NoSelect","name":"NoSelect","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"NoSelect leaves the destination session's current window unchanged."},"source":{"file":"tmux/window_link_move.go","line":59,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MoveWindowRequest.NoSelect","product":"core","slug":"tmux-movewindowrequest-noselect"},{"id":"tmux.MoveWindowRequest.KillTarget","name":"KillTarget","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KillTarget destroys a window already occupying the destination."},"source":{"file":"tmux/window_link_move.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MoveWindowRequest.KillTarget","product":"core","slug":"tmux-movewindowrequest-killtarget"},{"id":"tmux.MoveWindowRequest.Renumber","name":"Renumber","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Renumber renumbers the target session according to its base-index option instead of moving the receiver to a new destination."},"source":{"file":"tmux/window_link_move.go","line":64,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.MoveWindowRequest.Renumber","product":"core","slug":"tmux-movewindowrequest-renumber"},{"id":"tmux.Window.Link","name":"Link","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"LinkWindowRequest"}],"returns":"error"}],"doc":{"summary":"Link adds the stable window to TargetSession as another winlink, targeting the source through the receiver's exact session. Unless Detach is set, tmux makes the new link current in the target session; this is not a global client-focus guarantee. Link does not refresh or mutate the materialized source [Window]. A transport or context error can be delivery-ambiguous; the void result cannot carry the new winlink identity and no rollback is attempted."},"source":{"file":"tmux/window_link_move.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Link","product":"core","slug":"tmux-window-link"},{"id":"tmux.Window.Unlink","name":"Unlink","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"UnlinkWindowRequest"}],"returns":"error"}],"doc":{"summary":"Unlink removes the receiver's exact session winlink without refreshing the materialized receiver. Without KillIfLast, tmux rejects removal of a stable window's only link; with it, that window is destroyed. A transport or context error can be delivery-ambiguous; the void result cannot carry partial identity and no rollback is attempted."},"source":{"file":"tmux/window_link_move.go","line":149,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Unlink","product":"core","slug":"tmux-window-unlink"},{"id":"tmux.Window.Move","name":"Move","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"MoveWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"Move removes the receiver's exact winlink and places it in TargetSession, or renumbers the selected session when Renumber is set. Unless NoSelect is set, tmux makes the moved winlink current in the destination session; this is not a global client-focus guarantee. The stable WindowID does not by itself identify either linked view.","body":"Move returns a canonical freshly materialized [Window], which may use a\ndifferent linked session than the destination. If the command succeeds but\nrefresh fails, it returns the receiver with that error. Earlier failures\nreturn zero; transport errors are delivery-ambiguous."},"source":{"file":"tmux/window_link_move.go","line":174,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Move","product":"core","slug":"tmux-window-move"},{"id":"tmux.SwapWindowRequest","name":"SwapWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SwapWindowRequest configures swapping the receiver with one exact winlink on tmux 3.2a or later. Its zero value is invalid because Target must be a complete Window handle. The endpoints must be proven to share a daemon through connection state or the same nonempty SocketPath; matching socket names alone are insufficient. Validation completes before execution."},"source":{"file":"tmux/window_pane_swap.go","line":10,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapWindowRequest","product":"core","slug":"tmux-swapwindowrequest"},{"id":"tmux.SwapWindowRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.SwapWindowRequest","signatures":[],"type":"Window","doc":{"summary":"Target is the exact other winlink to swap with the receiver."},"source":{"file":"tmux/window_pane_swap.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapWindowRequest.Target","product":"core","slug":"tmux-swapwindowrequest-target"},{"id":"tmux.SwapWindowRequest.Detach","name":"Detach","kind":"attribute","modifiers":[],"parent":"tmux.SwapWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Detach leaves the affected sessions' current-window selection unchanged."},"source":{"file":"tmux/window_pane_swap.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapWindowRequest.Detach","product":"core","slug":"tmux-swapwindowrequest-detach"},{"id":"tmux.WindowSwapResult","name":"WindowSwapResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowSwapResult contains both original stable window identities in their post-swap exact winlink views. Its zero value contains no usable endpoints."},"source":{"file":"tmux/window_pane_swap.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSwapResult","product":"core","slug":"tmux-windowswapresult"},{"id":"tmux.WindowSwapResult.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.WindowSwapResult","signatures":[],"type":"Window","doc":{"summary":"Window is the receiver's original WindowID at its post-swap exact winlink."},"source":{"file":"tmux/window_pane_swap.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSwapResult.Window","product":"core","slug":"tmux-windowswapresult-window"},{"id":"tmux.WindowSwapResult.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.WindowSwapResult","signatures":[],"type":"Window","doc":{"summary":"Target is the target's original WindowID at its post-swap exact winlink."},"source":{"file":"tmux/window_pane_swap.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSwapResult.Target","product":"core","slug":"tmux-windowswapresult-target"},{"id":"tmux.SwapPaneDirection","name":"SwapPaneDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SwapPaneDirection selects an adjacent pane for swap-pane on tmux 3.2a or later. Its zero value selects no adjacent pane."},"source":{"file":"tmux/window_pane_swap.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneDirection","product":"core","slug":"tmux-swappanedirection"},{"id":"tmux.SwapPaneDirectionNone","name":"SwapPaneDirectionNone","kind":"constant","modifiers":[],"signatures":[],"type":"SwapPaneDirection","doc":{"summary":"SwapPaneDirectionNone selects no adjacent pane."},"source":{"file":"tmux/window_pane_swap.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneDirectionNone","product":"core","slug":"tmux-swappanedirectionnone"},{"id":"tmux.SwapPaneDirectionUp","name":"SwapPaneDirectionUp","kind":"constant","modifiers":[],"signatures":[],"type":"SwapPaneDirection","doc":{"summary":"SwapPaneDirectionUp swaps with the previous pane in index order."},"source":{"file":"tmux/window_pane_swap.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneDirectionUp","product":"core","slug":"tmux-swappanedirectionup"},{"id":"tmux.SwapPaneDirectionDown","name":"SwapPaneDirectionDown","kind":"constant","modifiers":[],"signatures":[],"type":"SwapPaneDirection","doc":{"summary":"SwapPaneDirectionDown swaps with the next pane in index order."},"source":{"file":"tmux/window_pane_swap.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneDirectionDown","product":"core","slug":"tmux-swappanedirectiondown"},{"id":"tmux.SwapPaneRequest","name":"SwapPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SwapPaneRequest configures swapping with an exact or adjacent pane on tmux 3.2a or later. Its zero value is invalid: exactly one complete Target or Direction is required. An explicit Target must differ from the receiver and must be proven to share a daemon through connection state or the same nonempty SocketPath; matching socket names alone are insufficient. Invalid choices are rejected before execution."},"source":{"file":"tmux/window_pane_swap.go","line":46,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneRequest","product":"core","slug":"tmux-swappanerequest"},{"id":"tmux.SwapPaneRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.SwapPaneRequest","signatures":[],"type":"Pane","doc":{"summary":"Target selects an exact other pane; a zero Pane omits it."},"source":{"file":"tmux/window_pane_swap.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneRequest.Target","product":"core","slug":"tmux-swappanerequest-target"},{"id":"tmux.SwapPaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.SwapPaneRequest","signatures":[],"type":"SwapPaneDirection","doc":{"summary":"Direction selects an adjacent pane; zero omits it."},"source":{"file":"tmux/window_pane_swap.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneRequest.Direction","product":"core","slug":"tmux-swappanerequest-direction"},{"id":"tmux.SwapPaneRequest.Detach","name":"Detach","kind":"attribute","modifiers":[],"parent":"tmux.SwapPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Detach leaves the active-pane selection unchanged."},"source":{"file":"tmux/window_pane_swap.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneRequest.Detach","product":"core","slug":"tmux-swappanerequest-detach"},{"id":"tmux.SwapPaneRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.SwapPaneRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the affected window's zoomed state."},"source":{"file":"tmux/window_pane_swap.go","line":54,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.SwapPaneRequest.KeepZoom","product":"core","slug":"tmux-swappanerequest-keepzoom"},{"id":"tmux.PaneSwapResult","name":"PaneSwapResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneSwapResult contains original stable pane identities in their post-swap exact linked-pane views. Its zero value contains no usable endpoints. Target is zero for a directional swap because tmux does not report the adjacent pane identity."},"source":{"file":"tmux/window_pane_swap.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSwapResult","product":"core","slug":"tmux-paneswapresult"},{"id":"tmux.PaneSwapResult.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.PaneSwapResult","signatures":[],"type":"Pane","doc":{"summary":"Pane is the receiver's original PaneID at its post-swap exact view."},"source":{"file":"tmux/window_pane_swap.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSwapResult.Pane","product":"core","slug":"tmux-paneswapresult-pane"},{"id":"tmux.PaneSwapResult.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.PaneSwapResult","signatures":[],"type":"Pane","doc":{"summary":"Target is the explicit target's original PaneID at its post-swap exact view, or zero after a directional swap."},"source":{"file":"tmux/window_pane_swap.go","line":66,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSwapResult.Target","product":"core","slug":"tmux-paneswapresult-target"},{"id":"tmux.Window.Swap","name":"Swap","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SwapWindowRequest"}],"returns":"(WindowSwapResult, error)"}],"doc":{"summary":"Swap exchanges the receiver and Target exact winlinks. Their stable WindowIDs move to the opposite session-and-index views; a WindowID alone does not identify either endpoint. Unless Detach is set, tmux may change the affected sessions' current-window selection; this is not a global client-focus guarantee.","body":"Swap returns both freshly materialized exact endpoint views. If exact\nrefresh fails after the command, it returns a predicted [WindowSwapResult]\ncarrying both stable IDs and post-swap session/index contexts with the\nerror. Earlier failures return zero; transport errors are delivery-ambiguous."},"source":{"file":"tmux/window_pane_swap.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Swap","product":"core","slug":"tmux-window-swap"},{"id":"tmux.Pane.Swap","name":"Swap","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SwapPaneRequest"}],"returns":"(PaneSwapResult, error)"}],"doc":{"summary":"Swap exchanges the receiver with one exact or adjacent pane. Explicit targets use exact linked-pane views; PaneID alone does not distinguish linked views. Unless Detach is set, tmux may change active-pane selection; this is not a global client-focus guarantee. A directional swap cannot identify the adjacent target because tmux does not report it, so the returned [PaneSwapResult].Target is zero.","body":"An explicit swap returns freshly materialized exact views for both original\nPaneIDs. If exact refresh fails after the command, Swap returns a predicted\nresult carrying every known identity with the error. Earlier failures return\nzero; transport errors are delivery-ambiguous."},"source":{"file":"tmux/window_pane_swap.go","line":133,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Swap","product":"core","slug":"tmux-pane-swap"},{"id":"tmux.PaneSelectDirection","name":"PaneSelectDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneSelectDirection selects a pane relative to the command target on tmux 3.2a or later. Its zero value selects no relative direction."},"source":{"file":"tmux/window_pane_topology.go","line":7,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectDirection","product":"core","slug":"tmux-paneselectdirection"},{"id":"tmux.PaneSelectDirectionNone","name":"PaneSelectDirectionNone","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionNone selects no relative pane."},"source":{"file":"tmux/window_pane_topology.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectDirectionNone","product":"core","slug":"tmux-paneselectdirectionnone"},{"id":"tmux.PaneSelectDirectionUp","name":"PaneSelectDirectionUp","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionUp selects the pane above the target."},"source":{"file":"tmux/window_pane_topology.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectDirectionUp","product":"core","slug":"tmux-paneselectdirectionup"},{"id":"tmux.PaneSelectDirectionDown","name":"PaneSelectDirectionDown","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionDown selects the pane below the target."},"source":{"file":"tmux/window_pane_topology.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectDirectionDown","product":"core","slug":"tmux-paneselectdirectiondown"},{"id":"tmux.PaneSelectDirectionLeft","name":"PaneSelectDirectionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionLeft selects the pane to the left of the target."},"source":{"file":"tmux/window_pane_topology.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectDirectionLeft","product":"core","slug":"tmux-paneselectdirectionleft"},{"id":"tmux.PaneSelectDirectionRight","name":"PaneSelectDirectionRight","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionRight selects the pane to the right of the target."},"source":{"file":"tmux/window_pane_topology.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectDirectionRight","product":"core","slug":"tmux-paneselectdirectionright"},{"id":"tmux.PaneSelectDirectionLast","name":"PaneSelectDirectionLast","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionLast selects the previously active pane."},"source":{"file":"tmux/window_pane_topology.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectDirectionLast","product":"core","slug":"tmux-paneselectdirectionlast"},{"id":"tmux.PaneMarkMode","name":"PaneMarkMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneMarkMode changes tmux's server-wide marked pane on tmux 3.2a or later. Its zero value leaves the mark unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneMarkMode","product":"core","slug":"tmux-panemarkmode"},{"id":"tmux.PaneMarkUnchanged","name":"PaneMarkUnchanged","kind":"constant","modifiers":[],"signatures":[],"type":"PaneMarkMode","doc":{"summary":"PaneMarkUnchanged leaves the server-wide marked pane unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneMarkUnchanged","product":"core","slug":"tmux-panemarkunchanged"},{"id":"tmux.PaneMarkSet","name":"PaneMarkSet","kind":"constant","modifiers":[],"signatures":[],"type":"PaneMarkMode","doc":{"summary":"PaneMarkSet makes the target the server-wide marked pane without selecting it."},"source":{"file":"tmux/window_pane_topology.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneMarkSet","product":"core","slug":"tmux-panemarkset"},{"id":"tmux.PaneMarkClear","name":"PaneMarkClear","kind":"constant","modifiers":[],"signatures":[],"type":"PaneMarkMode","doc":{"summary":"PaneMarkClear clears the server-wide marked pane without selecting the target."},"source":{"file":"tmux/window_pane_topology.go","line":38,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneMarkClear","product":"core","slug":"tmux-panemarkclear"},{"id":"tmux.PaneInputMode","name":"PaneInputMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneInputMode changes whether a pane accepts input on tmux 3.2a or later. Its zero value leaves input state unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneInputMode","product":"core","slug":"tmux-paneinputmode"},{"id":"tmux.PaneInputUnchanged","name":"PaneInputUnchanged","kind":"constant","modifiers":[],"signatures":[],"type":"PaneInputMode","doc":{"summary":"PaneInputUnchanged leaves the target pane's input state unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneInputUnchanged","product":"core","slug":"tmux-paneinputunchanged"},{"id":"tmux.PaneInputDisable","name":"PaneInputDisable","kind":"constant","modifiers":[],"signatures":[],"type":"PaneInputMode","doc":{"summary":"PaneInputDisable disables input without selecting the target pane."},"source":{"file":"tmux/window_pane_topology.go","line":50,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneInputDisable","product":"core","slug":"tmux-paneinputdisable"},{"id":"tmux.PaneInputEnable","name":"PaneInputEnable","kind":"constant","modifiers":[],"signatures":[],"type":"PaneInputMode","doc":{"summary":"PaneInputEnable enables input without selecting the target pane."},"source":{"file":"tmux/window_pane_topology.go","line":52,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneInputEnable","product":"core","slug":"tmux-paneinputenable"},{"id":"tmux.WindowSelectPaneRequest","name":"WindowSelectPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowSelectPaneRequest selects either one exact pane or one relative pane. Its zero value is invalid: exactly one of Target and Direction is required. Target must be a complete pane handle in the receiver's exact winlink and must be proven to share a daemon through connection state or the same nonempty SocketPath; matching socket names alone are insufficient. Invalid values are rejected before execution."},"source":{"file":"tmux/window_pane_topology.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSelectPaneRequest","product":"core","slug":"tmux-windowselectpanerequest"},{"id":"tmux.WindowSelectPaneRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.WindowSelectPaneRequest","signatures":[],"type":"Pane","doc":{"summary":"Target selects one exact pane in the receiver winlink; a zero Pane omits this choice."},"source":{"file":"tmux/window_pane_topology.go","line":64,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSelectPaneRequest.Target","product":"core","slug":"tmux-windowselectpanerequest-target"},{"id":"tmux.WindowSelectPaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.WindowSelectPaneRequest","signatures":[],"type":"PaneSelectDirection","doc":{"summary":"Direction selects a pane relative to the receiver window's active pane; zero omits this choice."},"source":{"file":"tmux/window_pane_topology.go","line":67,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSelectPaneRequest.Direction","product":"core","slug":"tmux-windowselectpanerequest-direction"},{"id":"tmux.WindowSelectPaneRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.WindowSelectPaneRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the window's zoomed state."},"source":{"file":"tmux/window_pane_topology.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowSelectPaneRequest.KeepZoom","product":"core","slug":"tmux-windowselectpanerequest-keepzoom"},{"id":"tmux.PaneSelectRequest","name":"PaneSelectRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneSelectRequest configures select-pane for one exact receiver. Closed enums prevent conflicting direction, mark, and input flags. Its zero value selects the receiver. Mark rejects every other option. Input rejects Direction and KeepZoom because changing input does not select a pane. These combinations and enum ranges are validated before execution."},"source":{"file":"tmux/window_pane_topology.go","line":77,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectRequest","product":"core","slug":"tmux-paneselectrequest"},{"id":"tmux.PaneSelectRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.PaneSelectRequest","signatures":[],"type":"PaneSelectDirection","doc":{"summary":"Direction selects a pane relative to the receiver; zero selects the receiver unless Mark or Input is set."},"source":{"file":"tmux/window_pane_topology.go","line":80,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectRequest.Direction","product":"core","slug":"tmux-paneselectrequest-direction"},{"id":"tmux.PaneSelectRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.PaneSelectRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the window's zoomed state while selecting."},"source":{"file":"tmux/window_pane_topology.go","line":82,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectRequest.KeepZoom","product":"core","slug":"tmux-paneselectrequest-keepzoom"},{"id":"tmux.PaneSelectRequest.Mark","name":"Mark","kind":"attribute","modifiers":[],"parent":"tmux.PaneSelectRequest","signatures":[],"type":"PaneMarkMode","doc":{"summary":"Mark changes the server-wide marked pane without selecting; zero leaves it unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":85,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectRequest.Mark","product":"core","slug":"tmux-paneselectrequest-mark"},{"id":"tmux.PaneSelectRequest.Input","name":"Input","kind":"attribute","modifiers":[],"parent":"tmux.PaneSelectRequest","signatures":[],"type":"PaneInputMode","doc":{"summary":"Input changes whether the receiver accepts input without selecting; zero leaves input state unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.PaneSelectRequest.Input","product":"core","slug":"tmux-paneselectrequest-input"},{"id":"tmux.LastPaneRequest","name":"LastPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"LastPaneRequest configures last-pane on tmux 3.2a or later. Its zero value selects the previously active pane. Input and KeepZoom are mutually exclusive and are validated before execution; an Input mode changes the previous pane's input state without selecting it."},"source":{"file":"tmux/window_pane_topology.go","line":95,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LastPaneRequest","product":"core","slug":"tmux-lastpanerequest"},{"id":"tmux.LastPaneRequest.Input","name":"Input","kind":"attribute","modifiers":[],"parent":"tmux.LastPaneRequest","signatures":[],"type":"PaneInputMode","doc":{"summary":"Input changes the previous pane's input state; zero performs selection."},"source":{"file":"tmux/window_pane_topology.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LastPaneRequest.Input","product":"core","slug":"tmux-lastpanerequest-input"},{"id":"tmux.LastPaneRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.LastPaneRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the window's zoomed state during selection."},"source":{"file":"tmux/window_pane_topology.go","line":99,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.LastPaneRequest.KeepZoom","product":"core","slug":"tmux-lastpanerequest-keepzoom"},{"id":"tmux.RotateWindowDirection","name":"RotateWindowDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RotateWindowDirection selects rotate-window's direction on tmux 3.2a or later. Its zero value uses tmux's default rotation."},"source":{"file":"tmux/window_pane_topology.go","line":104,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RotateWindowDirection","product":"core","slug":"tmux-rotatewindowdirection"},{"id":"tmux.RotateWindowDefault","name":"RotateWindowDefault","kind":"constant","modifiers":[],"signatures":[],"type":"RotateWindowDirection","doc":{"summary":"RotateWindowDefault uses tmux's default rotation."},"source":{"file":"tmux/window_pane_topology.go","line":109,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RotateWindowDefault","product":"core","slug":"tmux-rotatewindowdefault"},{"id":"tmux.RotateWindowUp","name":"RotateWindowUp","kind":"constant","modifiers":[],"signatures":[],"type":"RotateWindowDirection","doc":{"summary":"RotateWindowUp rotates pane positions toward lower indexes."},"source":{"file":"tmux/window_pane_topology.go","line":111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RotateWindowUp","product":"core","slug":"tmux-rotatewindowup"},{"id":"tmux.RotateWindowDown","name":"RotateWindowDown","kind":"constant","modifiers":[],"signatures":[],"type":"RotateWindowDirection","doc":{"summary":"RotateWindowDown rotates pane positions toward higher indexes."},"source":{"file":"tmux/window_pane_topology.go","line":113,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RotateWindowDown","product":"core","slug":"tmux-rotatewindowdown"},{"id":"tmux.RotateWindowRequest","name":"RotateWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RotateWindowRequest configures rotate-window. Its zero value uses tmux's default rotation; enum validation happens before execution."},"source":{"file":"tmux/window_pane_topology.go","line":118,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RotateWindowRequest","product":"core","slug":"tmux-rotatewindowrequest"},{"id":"tmux.RotateWindowRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.RotateWindowRequest","signatures":[],"type":"RotateWindowDirection","doc":{"summary":"Direction selects the rotation direction; zero uses tmux's default."},"source":{"file":"tmux/window_pane_topology.go","line":120,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RotateWindowRequest.Direction","product":"core","slug":"tmux-rotatewindowrequest-direction"},{"id":"tmux.RotateWindowRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.RotateWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the window's zoomed state."},"source":{"file":"tmux/window_pane_topology.go","line":122,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RotateWindowRequest.KeepZoom","product":"core","slug":"tmux-rotatewindowrequest-keepzoom"},{"id":"tmux.Window.SelectPane","name":"SelectPane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"WindowSelectPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"SelectPane makes an exact or relative pane active in the receiver's exact winlink without selecting the window in its session. Target must belong to that same SessionID and WindowID; a PaneID alone does not identify a linked view. The returned [Pane] is the freshly materialized active pane in the receiver context, not a canonical ID-only view.","body":"Command or refresh failures return zero because active-pane selection has no\nreliable partial identity. Transport errors are delivery-ambiguous."},"source":{"file":"tmux/window_pane_topology.go","line":133,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.SelectPane","product":"core","slug":"tmux-window-selectpane"},{"id":"tmux.Pane.Select","name":"Select","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PaneSelectRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Select applies select-pane to the receiver's exact linked-pane view. Direction makes an adjacent pane active, but the returned [Pane] is a fresh exact refresh of the receiver rather than the newly active pane. With no Direction, Mark, or Input, the receiver becomes active. Mark changes the server-wide marked pane without selection; Input changes the receiver's input state without selection. None of these modes selects the window in its session or promises client focus.","body":"A refresh failure returns the receiver with the error; earlier failures return zero."},"source":{"file":"tmux/window_pane_topology.go","line":186,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Pane.Select","product":"core","slug":"tmux-pane-select"},{"id":"tmux.Window.LastPane","name":"LastPane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"LastPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"LastPane targets the receiver's exact winlink. Its zero request makes the previously active pane active without selecting the window in its session. With an Input mode, tmux changes the previous pane's input state without selecting it; the returned [Pane] is still the freshly materialized active pane in the receiver context.","body":"Command or refresh failures return zero because the active view needs refresh."},"source":{"file":"tmux/window_pane_topology.go","line":213,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.LastPane","product":"core","slug":"tmux-window-lastpane"},{"id":"tmux.Window.Rotate","name":"Rotate","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RotateWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"Rotate rotates pane positions in the receiver's exact winlink without selecting the window or promising client focus. It returns a freshly materialized exact [Window] preserving the receiver SessionID, rather than a canonical ID-only view. If the command succeeds but refresh fails, Rotate returns the receiver with that error; earlier failures return zero."},"source":{"file":"tmux/window_pane_topology.go","line":247,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Rotate","product":"core","slug":"tmux-window-rotate"},{"id":"tmux.WindowResizeDirection","name":"WindowResizeDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowResizeDirection selects one directional resize operation on tmux 3.2a or later. Its zero value selects no directional adjustment."},"source":{"file":"tmux/window_resize.go","line":10,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowResizeDirection","product":"core","slug":"tmux-windowresizedirection"},{"id":"tmux.WindowResizeDirectionNone","name":"WindowResizeDirectionNone","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionNone selects no directional adjustment."},"source":{"file":"tmux/window_resize.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowResizeDirectionNone","product":"core","slug":"tmux-windowresizedirectionnone"},{"id":"tmux.WindowResizeDirectionUp","name":"WindowResizeDirectionUp","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionUp adjusts the window upward."},"source":{"file":"tmux/window_resize.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowResizeDirectionUp","product":"core","slug":"tmux-windowresizedirectionup"},{"id":"tmux.WindowResizeDirectionDown","name":"WindowResizeDirectionDown","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionDown adjusts the window downward."},"source":{"file":"tmux/window_resize.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowResizeDirectionDown","product":"core","slug":"tmux-windowresizedirectiondown"},{"id":"tmux.WindowResizeDirectionLeft","name":"WindowResizeDirectionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionLeft adjusts the window leftward."},"source":{"file":"tmux/window_resize.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowResizeDirectionLeft","product":"core","slug":"tmux-windowresizedirectionleft"},{"id":"tmux.WindowResizeDirectionRight","name":"WindowResizeDirectionRight","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionRight adjusts the window rightward."},"source":{"file":"tmux/window_resize.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.WindowResizeDirectionRight","product":"core","slug":"tmux-windowresizedirectionright"},{"id":"tmux.ResizeWindowRequest","name":"ResizeWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ResizeWindowRequest selects one directional, manual, expand, or shrink operation. Height and Width may be set together. A zero request asks tmux to reapply the current manual size. Direction requires a positive Adjustment; that pair, dimensions, Expand, and Shrink are mutually exclusive and are validated before execution. Zero Adjustment, Height, and Width omit their modes; nonzero values must be positive. The request is supported on tmux 3.2a or later."},"source":{"file":"tmux/window_resize.go","line":33,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizeWindowRequest","product":"core","slug":"tmux-resizewindowrequest"},{"id":"tmux.ResizeWindowRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"WindowResizeDirection","doc":{"summary":"Direction selects a directional adjustment; zero selects another mode."},"source":{"file":"tmux/window_resize.go","line":35,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizeWindowRequest.Direction","product":"core","slug":"tmux-resizewindowrequest-direction"},{"id":"tmux.ResizeWindowRequest.Adjustment","name":"Adjustment","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"int","doc":{"summary":"Adjustment is the required positive amount for Direction; zero omits it."},"source":{"file":"tmux/window_resize.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizeWindowRequest.Adjustment","product":"core","slug":"tmux-resizewindowrequest-adjustment"},{"id":"tmux.ResizeWindowRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"int","doc":{"summary":"Height sets a positive manual height; zero preserves the current height."},"source":{"file":"tmux/window_resize.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizeWindowRequest.Height","product":"core","slug":"tmux-resizewindowrequest-height"},{"id":"tmux.ResizeWindowRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"int","doc":{"summary":"Width sets a positive manual width; zero preserves the current width."},"source":{"file":"tmux/window_resize.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizeWindowRequest.Width","product":"core","slug":"tmux-resizewindowrequest-width"},{"id":"tmux.ResizeWindowRequest.Expand","name":"Expand","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Expand sets the window to the size of the largest session containing it."},"source":{"file":"tmux/window_resize.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizeWindowRequest.Expand","product":"core","slug":"tmux-resizewindowrequest-expand"},{"id":"tmux.ResizeWindowRequest.Shrink","name":"Shrink","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Shrink sets the window to the size of the smallest session containing it."},"source":{"file":"tmux/window_resize.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.ResizeWindowRequest.Shrink","product":"core","slug":"tmux-resizewindowrequest-shrink"},{"id":"tmux.Window.Resize","name":"Resize","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ResizeWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"Resize changes the stable window's size through the receiver's exact winlink. It does not select the window or promise any client focus. Resize returns a canonical freshly materialized [Window], which may use another linked session for the same WindowID. If the command succeeds but refresh fails, it returns the receiver with that error; other command failures return a zero Window. A transport or context error can be delivery-ambiguous and no rollback is attempted."},"source":{"file":"tmux/window_resize.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Resize","product":"core","slug":"tmux-window-resize"},{"id":"tmux.RespawnRequest","name":"RespawnRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RespawnRequest configures restarting a window's or pane's process on tmux 3.2a or later. Its zero value reuses the stored command and directory and requires the target process to be inactive. Nil pointer fields omit their options; nonnil pointers are explicit, including empty strings. There are no mutually exclusive fields. Arguments and environment entries are validated before execution.","body":"Methods read pointer and map values during argument construction; do not\nmutate them concurrently."},"source":{"file":"tmux/window_respawn.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RespawnRequest","product":"core","slug":"tmux-respawnrequest"},{"id":"tmux.RespawnRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.RespawnRequest","signatures":[],"type":"*string","doc":{"summary":"Command is omitted when nil so tmux reuses the stored command. A nonnil empty string remains an explicit operand."},"source":{"file":"tmux/window_respawn.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RespawnRequest.Command","product":"core","slug":"tmux-respawnrequest-command"},{"id":"tmux.RespawnRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.RespawnRequest","signatures":[],"type":"*string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Nil reuses the stored directory; a nonnil empty string selects the current directory."},"source":{"file":"tmux/window_respawn.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RespawnRequest.StartDirectory","product":"core","slug":"tmux-respawnrequest-startdirectory"},{"id":"tmux.RespawnRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.RespawnRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order; nil and an empty map both add no environment entries."},"source":{"file":"tmux/window_respawn.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RespawnRequest.Environment","product":"core","slug":"tmux-respawnrequest-environment"},{"id":"tmux.RespawnRequest.Kill","name":"Kill","kind":"attribute","modifiers":[],"parent":"tmux.RespawnRequest","signatures":[],"type":"bool","doc":{"summary":"Kill terminates an active target process before restarting it."},"source":{"file":"tmux/window_respawn.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.RespawnRequest.Kill","product":"core","slug":"tmux-respawnrequest-kill"},{"id":"tmux.Window.Respawn","name":"Respawn","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RespawnRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"Respawn restarts the stable window process through the receiver's exact winlink. It does not select the window or promise any client focus. Respawn returns a canonical freshly materialized [Window], which may use another linked session for the same WindowID. If the command succeeds but refresh fails, it returns the receiver with that error; earlier failures return zero. Completed stderr produces a redacted [CommandError]; nonzero exits without stderr are followed by refresh."},"source":{"file":"tmux/window_respawn.go","line":39,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmux.Window.Respawn","product":"core","slug":"tmux-window-respawn"},{"id":"tmuxtest.ControlMode","name":"ControlMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlMode is an attached tmux control client for real-tmux tests. It owns one stdout reader and a temporary-file spool, which preserves unread protocol output until [ControlMode.Close] releases it. Instances come from [NewControlMode]; do not construct them directly or read concurrently."},"source":{"file":"tmux/tmuxtest/control.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ControlMode","product":"core","slug":"tmuxtest-controlmode"},{"id":"tmuxtest.NewControlMode","name":"NewControlMode","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"server","type":"tmux.Server"},{"name":"session","type":"tmux.Session"}],"returns":"*ControlMode"}],"doc":{"summary":"NewControlMode starts a [ControlMode] attached to session and registers cleanup with t. It requires an explicitly configured process environment and validates that session belongs to server. The client pins the server's frozen effective socket path. Validation or startup failures call [testing.TB.Fatal]. ctx bounds startup and registration only, not the returned client's lifetime."},"source":{"file":"tmux/tmuxtest/control.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.NewControlMode","product":"core","slug":"tmuxtest-newcontrolmode"},{"id":"tmuxtest.ControlMode.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts an idempotent shutdown and waits within ctx. Concurrent calls join the same shutdown. If ctx ends after shutdown starts, shutdown continues and a later call may wait for completion; an already-ended ctx does not start shutdown."},"source":{"file":"tmux/tmuxtest/control.go","line":74,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ControlMode.CloseContext","product":"core","slug":"tmuxtest-controlmode-closecontext"},{"id":"tmuxtest.ControlMode.ClientName","name":"ClientName","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[],"returns":"tmux.ClientName"}],"doc":{"summary":"ClientName returns the tmux-assigned identity captured at registration."},"source":{"file":"tmux/tmuxtest/control.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ControlMode.ClientName","product":"core","slug":"tmuxtest-controlmode-clientname"},{"id":"tmuxtest.ControlMode.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[],"returns":"tmux.Server"}],"doc":{"summary":"Server returns the validated server handle captured at construction."},"source":{"file":"tmux/tmuxtest/control.go","line":93,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ControlMode.Server","product":"core","slug":"tmuxtest-controlmode-server"},{"id":"tmuxtest.ControlMode.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[],"returns":"tmux.Session"}],"doc":{"summary":"Session returns the validated session handle captured at construction."},"source":{"file":"tmux/tmuxtest/control.go","line":98,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ControlMode.Session","product":"core","slug":"tmuxtest-controlmode-session"},{"id":"tmuxtest.ControlMode.Read","name":"Read","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"data","type":"[]byte"}],"returns":"(int, error)"}],"doc":{"summary":"Read reads control-protocol output within ctx. Exactly one caller may read at a time. After the client exits, callers may drain preserved output through [io.EOF]; after [ControlMode.Close], a non-empty Read returns [os.ErrClosed]. It returns ctx errors while waiting for output."},"source":{"file":"tmux/tmuxtest/control.go","line":106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ControlMode.Read","product":"core","slug":"tmuxtest-controlmode-read"},{"id":"tmuxtest.ControlMode.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Wait blocks until the control client exits or ctx ends. It does not stop or close the client; use [ControlMode.Close] to release it."},"source":{"file":"tmux/tmuxtest/control.go","line":112,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ControlMode.Wait","product":"core","slug":"tmuxtest-controlmode-wait"},{"id":"tmuxtest.ControlMode.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the control client and releases its output spool. It is safe to call concurrently and more than once."},"source":{"file":"tmux/tmuxtest/control.go","line":123,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ControlMode.Close","product":"core","slug":"tmuxtest-controlmode-close"},{"id":"tmuxtest.ServerOptions","name":"ServerOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerOptions configures a harness-owned [tmux.Server]. All inputs are copied before filesystem or process operations, so callers retain ownership."},"source":{"file":"tmux/tmuxtest/harness.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ServerOptions","product":"core","slug":"tmuxtest-serveroptions"},{"id":"tmuxtest.ServerOptions.Binary","name":"Binary","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"string","doc":{"summary":"Binary is the tmux executable. An empty value resolves tmux from PATH."},"source":{"file":"tmux/tmuxtest/harness.go","line":99,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ServerOptions.Binary","product":"core","slug":"tmuxtest-serveroptions-binary"},{"id":"tmuxtest.ServerOptions.Config","name":"Config","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"[]byte","doc":{"summary":"Config is appended to the harness-owned config file; it cannot replace the private file that prevents user configuration from loading."},"source":{"file":"tmux/tmuxtest/harness.go","line":102,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ServerOptions.Config","product":"core","slug":"tmuxtest-serveroptions-config"},{"id":"tmuxtest.ServerOptions.ProcessEnvironment","name":"ProcessEnvironment","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"[]string","doc":{"summary":"ProcessEnvironment supplies the server environment. Nil snapshots the current process environment, while a non-nil empty slice remains empty. Tmux targeting variables are removed in either case."},"source":{"file":"tmux/tmuxtest/harness.go","line":106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ServerOptions.ProcessEnvironment","product":"core","slug":"tmuxtest-serveroptions-processenvironment"},{"id":"tmuxtest.ServerOptions.InitialSession","name":"InitialSession","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"*tmux.NewSessionRequest","doc":{"summary":"InitialSession starts the daemon with this copied request. Nil returns a lazy bare server; a later tmux command may start it."},"source":{"file":"tmux/tmuxtest/harness.go","line":109,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ServerOptions.InitialSession","product":"core","slug":"tmuxtest-serveroptions-initialsession"},{"id":"tmuxtest.ServerOptions.FixedShell","name":"FixedShell","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"bool","doc":{"summary":"FixedShell gives panes without an explicit command a POSIX shell with no startup files and the prompt ShellPrompt. RunInPane sets it; the default preserves tmux process behavior for tests that need it."},"source":{"file":"tmux/tmuxtest/harness.go","line":113,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ServerOptions.FixedShell","product":"core","slug":"tmuxtest-serveroptions-fixedshell"},{"id":"tmuxtest.ShellPrompt","name":"ShellPrompt","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ShellPrompt is the prompt drawn when [ServerOptions.FixedShell] is enabled."},"source":{"file":"tmux/tmuxtest/harness.go","line":117,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ShellPrompt","product":"core","slug":"tmuxtest-shellprompt"},{"id":"tmuxtest.SuiteRootTagVariable","name":"SuiteRootTagVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"SuiteRootTagVariable names the environment variable that tags a suite's temporary root. go test runs packages in parallel and every suite among them creates a root beside the others, so a test spawning a child suite sets this to tell its child's root from theirs."},"source":{"file":"tmux/tmuxtest/harness.go","line":224,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.SuiteRootTagVariable","product":"core","slug":"tmuxtest-suiteroottagvariable"},{"id":"tmuxtest.Main","name":"Main","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"m","type":"*testing.M"}],"returns":"int"}],"doc":{"summary":"Main runs the one-call package lifecycle for tmuxtest. It prepares short temporary paths, redirects [suiteEnvironment] into them, runs m, cleans registered servers, restores the environment, and returns the final status. TestMain should return its result through [os.Exit]."},"source":{"file":"tmux/tmuxtest/harness.go","line":237,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.Main","product":"core","slug":"tmuxtest-main"},{"id":"tmuxtest.NewServer","name":"NewServer","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"}],"returns":"tmux.Server"}],"doc":{"summary":"NewServer starts an isolated [tmux.Server] with a session named \"work\". Startup uses ctx and the harness timeout, whichever ends first. It registers bounded cleanup with t; setup failures call [testing.TB.Fatal]. The context does not govern later server cleanup or daemon lifetime."},"source":{"file":"tmux/tmuxtest/harness.go","line":307,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.NewServer","product":"core","slug":"tmuxtest-newserver"},{"id":"tmuxtest.NewServerWithOptions","name":"NewServerWithOptions","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"options","type":"ServerOptions"}],"returns":"tmux.Server"}],"doc":{"summary":"NewServerWithOptions prepares an isolated harness-owned [tmux.Server] from options. Initial startup uses ctx and the harness timeout, whichever ends first. The daemon starts only when [ServerOptions.InitialSession] is non-nil or a later tmux command starts it. It registers bounded cleanup with t; setup failures call [testing.TB.Fatal]. The context does not govern later cleanup or daemon lifetime."},"source":{"file":"tmux/tmuxtest/harness.go","line":320,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.NewServerWithOptions","product":"core","slug":"tmuxtest-newserverwithoptions"},{"id":"tmuxtest.PTYProcess","name":"PTYProcess","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PTYProcess is a test subprocess that owns an isolated controlling terminal and a memory-backed transcript. It comes from [StartPTYProcess]. Output may be read concurrently through [PTYProcess.Output]; writes are serialized."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.PTYProcess","product":"core","slug":"tmuxtest-ptyprocess"},{"id":"tmuxtest.StartPTYProcess","name":"StartPTYProcess","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"binary","type":"string"},{"name":"arguments","type":"[]string"},{"name":"environment","type":"[]string"}],"returns":"*PTYProcess"}],"doc":{"summary":"StartPTYProcess starts binary with a harness-owned controlling terminal and registers bounded cleanup with t. Its start context owns the child lifetime: canceling ctx terminates the child. Arguments and environment are copied. A nil environment inherits the current process environment; a non-nil empty environment remains empty. binary runs directly without a shell. The PTY backend is supported on Linux only; unsupported platforms call [testing.TB.Fatal]. Setup failures also call [testing.TB.Fatal]."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.StartPTYProcess","product":"core","slug":"tmuxtest-startptyprocess"},{"id":"tmuxtest.PTYProcess.Done","name":"Done","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[],"returns":"<-chan struct{}"}],"doc":{"summary":"Done is closed when the subprocess exits. It can close before the terminal reader has added the final bytes to [PTYProcess.Output]."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":109,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.PTYProcess.Done","product":"core","slug":"tmuxtest-ptyprocess-done"},{"id":"tmuxtest.PTYProcess.Write","name":"Write","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"input","type":"[]byte"}],"returns":"(int, error)"}],"doc":{"summary":"Write sends terminal input to the subprocess within ctx. Writes are serialized and can be partial. A waiting caller may cancel before acquiring the writer, and an active write observes ctx cancellation."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":114,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.PTYProcess.Write","product":"core","slug":"tmuxtest-ptyprocess-write"},{"id":"tmuxtest.PTYProcess.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Wait waits for process completion and the final output drain, or ctx cancellation. A successful Wait guarantees that [PTYProcess.Output] contains the completed transcript."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":156,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.PTYProcess.Wait","product":"core","slug":"tmuxtest-ptyprocess-wait"},{"id":"tmuxtest.PTYProcess.Output","name":"Output","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[],"returns":"[]byte"}],"doc":{"summary":"Output returns a fresh copy of terminal output collected so far. A successful [PTYProcess.Wait] guarantees that the returned transcript includes the final drain."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":173,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.PTYProcess.Output","product":"core","slug":"tmuxtest-ptyprocess-output"},{"id":"tmuxtest.PTYProcess.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the subprocess if needed and releases the PTY master. It is safe to call concurrently and more than once."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":177,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.PTYProcess.Close","product":"core","slug":"tmuxtest-ptyprocess-close"},{"id":"tmuxtest.PTYProcess.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts an idempotent shutdown and waits within ctx. Concurrent calls join the same shutdown. If ctx ends after shutdown starts, shutdown continues and a later call may wait for completion; an already-ended ctx does not start shutdown."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":189,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.PTYProcess.CloseContext","product":"core","slug":"tmuxtest-ptyprocess-closecontext"},{"id":"tmuxtest.TemporaryNamePrefix","name":"TemporaryNamePrefix","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"TemporaryNamePrefix prefixes names generated by [NewSession] and [NewWindow]."},"source":{"file":"tmux/tmuxtest/resources.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.TemporaryNamePrefix","product":"core","slug":"tmuxtest-temporarynameprefix"},{"id":"tmuxtest.NewSession","name":"NewSession","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"server","type":"tmux.Server"},{"name":"request","type":"tmux.NewSessionRequest"}],"returns":"tmux.Session"}],"doc":{"summary":"NewSession creates a test-owned [tmux.Session] and registers cleanup against its stable ID. An empty [tmux.NewSessionRequest.Name] receives a collision-checked temporary name. The request and referenced values are copied before tmux is called, and setup failures call [testing.TB.Fatal]. Cleanup belongs to t rather than ctx and continues to target the session if it is renamed."},"source":{"file":"tmux/tmuxtest/resources.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.NewSession","product":"core","slug":"tmuxtest-newsession"},{"id":"tmuxtest.NewWindow","name":"NewWindow","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"session","type":"tmux.Session"},{"name":"request","type":"tmux.NewWindowRequest"}],"returns":"tmux.Window"}],"doc":{"summary":"NewWindow creates a test-owned [tmux.Window] and registers cleanup against its stable ID. A nil [tmux.NewWindowRequest.Name] receives a collision-checked temporary name; an empty non-nil name remains explicit. The request and referenced values are copied before tmux is called, and setup failures call [testing.TB.Fatal]. Cleanup belongs to t rather than ctx and follows the window if it is moved."},"source":{"file":"tmux/tmuxtest/resources.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.NewWindow","product":"core","slug":"tmuxtest-newwindow"},{"id":"tmuxtest.Screen","name":"Screen","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"}],"returns":"[]string"}],"doc":{"summary":"Screen returns the pane's visible lines, top to bottom, with tmux's trailing blank lines removed.","body":"Scrolled-out output is excluded. Use [tmux.Pane.Capture] with\n[tmux.CaptureBoundary] to read scrollback.\n\nRead failures call [testing.TB.Fatal]."},"source":{"file":"tmux/tmuxtest/screen.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.Screen","product":"core","slug":"tmuxtest-screen"},{"id":"tmuxtest.WaitForText","name":"WaitForText","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"text","type":"string"}]}],"doc":{"summary":"WaitForText blocks until some line of the pane's screen contains text.","body":"A pane that never shows text fails the test with the screen it last read."},"source":{"file":"tmux/tmuxtest/screen.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.WaitForText","product":"core","slug":"tmuxtest-waitfortext"},{"id":"tmuxtest.WaitForLine","name":"WaitForLine","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"line","type":"string"}]}],"doc":{"summary":"WaitForLine blocks until some line of the pane's screen is exactly line.","body":"A pane that never shows line fails the test with the screen it last read."},"source":{"file":"tmux/tmuxtest/screen.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.WaitForLine","product":"core","slug":"tmuxtest-waitforline"},{"id":"tmuxtest.WaitForScreen","name":"WaitForScreen","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"want","type":"string"},{"name":"match","type":"func(screen []string) bool"}]}],"doc":{"summary":"WaitForScreen blocks until the pane's screen satisfies match.","body":"want is the noun phrase used in the failure message.\n\nmatch receives a newly read screen and must not retain it."},"source":{"file":"tmux/tmuxtest/screen.go","line":70,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.WaitForScreen","product":"core","slug":"tmuxtest-waitforscreen"},{"id":"tmuxtest.WaitForShellReady","name":"WaitForShellReady","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"}]}],"doc":{"summary":"WaitForShellReady blocks until the pane first shows output. With [ServerOptions.FixedShell], that expected first output is the harness prompt and serves as readiness evidence; custom shell startup output may not.","body":"[RunInPane] calls it, and a test building its own pane should too."},"source":{"file":"tmux/tmuxtest/screen.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.WaitForShellReady","product":"core","slug":"tmuxtest-waitforshellready"},{"id":"tmuxtest.Type","name":"Type","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"command","type":"string"}]}],"doc":{"summary":"Type sends command to the pane and submits it, as a person at the keyboard would.","body":"command is sent literally. Type returns when tmux accepts the keys, before the\nshell finishes; follow it with a wait when completion matters."},"source":{"file":"tmux/tmuxtest/screen.go","line":115,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.Type","product":"core","slug":"tmuxtest-type"},{"id":"tmuxtest.TypeAndWait","name":"TypeAndWait","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"command","type":"string"}]}],"doc":{"summary":"TypeAndWait sends command to the pane and blocks until it has finished.","body":"It appends and waits for a unique marker whether the command succeeds or\nfails. It does not return the command's exit status."},"source":{"file":"tmux/tmuxtest/screen.go","line":129,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.TypeAndWait","product":"core","slug":"tmuxtest-typeandwait"},{"id":"tmuxtest.RunInPane","name":"RunInPane","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"command","type":"string"}],"returns":"tmux.Pane"}],"doc":{"summary":"RunInPane creates an isolated pane, waits for its startup-file-free POSIX shell, and submits command with [Type]. It does not wait for command to start or finish. Resources belong to t; setup failures call [testing.TB.Fatal]. Use [NewServerWithOptions] for custom topology or configuration."},"source":{"file":"tmux/tmuxtest/screen.go","line":155,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.RunInPane","product":"core","slug":"tmuxtest-runinpane"},{"id":"tmuxtest.ScriptedCommand","name":"ScriptedCommand","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ScriptedCommand is one answer a scripted tmux gives. The first matching entry wins, and an invocation nothing matches exits 1 saying so."},"source":{"file":"tmux/tmuxtest/scripted.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ScriptedCommand","product":"core","slug":"tmuxtest-scriptedcommand"},{"id":"tmuxtest.ScriptedCommand.Contains","name":"Contains","kind":"attribute","modifiers":[],"parent":"tmuxtest.ScriptedCommand","signatures":[],"type":"[]string","doc":{"summary":"Contains selects the invocations this entry answers: one matches when its arguments contain every string listed, so \"list-sessions\" answers that subcommand whatever flags surround it. Empty matches every invocation."},"source":{"file":"tmux/tmuxtest/scripted.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ScriptedCommand.Contains","product":"core","slug":"tmuxtest-scriptedcommand-contains"},{"id":"tmuxtest.ScriptedCommand.Stdout","name":"Stdout","kind":"attribute","modifiers":[],"parent":"tmuxtest.ScriptedCommand","signatures":[],"type":"string","doc":{"summary":"Stdout is written to standard output exactly, newlines included."},"source":{"file":"tmux/tmuxtest/scripted.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ScriptedCommand.Stdout","product":"core","slug":"tmuxtest-scriptedcommand-stdout"},{"id":"tmuxtest.ScriptedCommand.Stderr","name":"Stderr","kind":"attribute","modifiers":[],"parent":"tmuxtest.ScriptedCommand","signatures":[],"type":"string","doc":{"summary":"Stderr is written to standard error exactly, newlines included. This package reads a completed failure from stderr rather than from an exit code, so an entry standing in for one sets this."},"source":{"file":"tmux/tmuxtest/scripted.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ScriptedCommand.Stderr","product":"core","slug":"tmuxtest-scriptedcommand-stderr"},{"id":"tmuxtest.ScriptedCommand.ExitCode","name":"ExitCode","kind":"attribute","modifiers":[],"parent":"tmuxtest.ScriptedCommand","signatures":[],"type":"int","doc":{"summary":"ExitCode is the status the invocation exits with."},"source":{"file":"tmux/tmuxtest/scripted.go","line":26,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ScriptedCommand.ExitCode","product":"core","slug":"tmuxtest-scriptedcommand-exitcode"},{"id":"tmuxtest.ScriptedTmux","name":"ScriptedTmux","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"t","type":"testing.TB"},{"name":"script","type":"ScriptedCommand"}],"returns":"string"}],"doc":{"summary":"ScriptedTmux writes an executable that answers tmux invocations from script and returns its absolute path, for [tmux.ServerOptions.Binary]. It is how a test drives code that uses this package without a tmux to drive:","body":"server, err := tmux.NewServer(tmux.ServerOptions{\n\tBinary: tmuxtest.ScriptedTmux(t,\n\t\ttmuxtest.ScriptedCommand{Contains: []string{\"-V\"}, Stdout: \"tmux 3.7\\n\"},\n\t\ttmuxtest.ScriptedCommand{\n\t\t\tContains: []string{\"kill-pane\"},\n\t\t\tStderr:   \"can't find pane: %7\\n\",\n\t\t\tExitCode: 1,\n\t\t},\n\t),\n})\n\nThe executable is removed with the test. It answers commands only: opening a\ncontrol connection or a notification stream speaks tmux's control protocol,\nwhich a script cannot, so code that opens one needs [NewServer] and a real\ntmux."},"source":{"file":"tmux/tmuxtest/scripted.go","line":48,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.ScriptedTmux","product":"core","slug":"tmuxtest-scriptedtmux"},{"id":"tmuxtest.WaitFor","name":"WaitFor","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"interval","type":"time.Duration"},{"name":"condition","type":"func(context.Context) (bool, error)"}],"returns":"error"}],"doc":{"summary":"WaitFor checks condition serially and immediately, then after each interval, until it succeeds, returns an error, or ctx ends. It validates interval, condition, and ctx in that order: interval must be positive, condition must be non-nil, and an already-ended context prevents every check. Condition errors and context errors are returned unchanged. A running condition receives ctx and must observe it itself; WaitFor cannot interrupt the condition."},"source":{"file":"tmux/tmuxtest/wait.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxtest.WaitFor","product":"core","slug":"tmuxtest-waitfor"},{"id":"tmuxq.Filter","name":"Filter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Filter is anything that compiles itself into a predicate over T, which is what the tmux package's generated model filters do. It exists so a filter and a query can meet without this package naming a model."},"source":{"file":"tmuxq/filter.go","line":8,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.Filter","product":"core","slug":"tmuxq-filter"},{"id":"tmuxq.Matching","name":"Matching","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"[]T"},{"name":"filter","type":"Filter[T]"}],"returns":"([]T, error)","typeParams":["T any"]}],"doc":{"summary":"Matching returns a fresh slice of shallow copies for values that filter accepts, retaining their source order, and reports the one error a filter can have rather than leaving it for the caller to unpack first. It evaluates every input value, so a no-match result is an empty slice.","body":"active, err := tmuxq.Matching(snapshot.Panes(), tmux.PaneActiveIs(true))"},"source":{"file":"tmuxq/filter.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.Matching","product":"core","slug":"tmuxq-matching"},{"id":"tmuxq.MatchingSeq","name":"MatchingSeq","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"iter.Seq[T]"},{"name":"filter","type":"Filter[T]"}],"returns":"(iter.Seq[T], error)","typeParams":["T any"]}],"doc":{"summary":"MatchingSeq returns a lazy sequence of shallow copies for values that filter accepts, retaining source order. The filter is compiled before iteration begins, so an invalid filter is an error here rather than a sequence that yields nothing."},"source":{"file":"tmuxq/filter.go","line":32,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.MatchingSeq","product":"core","slug":"tmuxq-matchingseq"},{"id":"tmuxq.ErrNoMatch","name":"ErrNoMatch","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrNoMatch identifies an ExactlyOne or ExactlyOneSeq query with no matching value. Cardinality errors can be checked with errors.Is."},"source":{"file":"tmuxq/query.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.ErrNoMatch","product":"core","slug":"tmuxq-errnomatch"},{"id":"tmuxq.ErrMultipleMatches","name":"ErrMultipleMatches","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMultipleMatches identifies an ExactlyOne or ExactlyOneSeq query with more than one matching value. The queries stop when they find the second match. Cardinality errors can be checked with errors.Is."},"source":{"file":"tmuxq/query.go","line":17,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.ErrMultipleMatches","product":"core","slug":"tmuxq-errmultiplematches"},{"id":"tmuxq.Where","name":"Where","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"[]T"},{"name":"predicate","type":"func(*T) bool"}],"returns":"[]T","typeParams":["T any"]}],"doc":{"summary":"Where returns a fresh slice of shallow copies for values accepted by predicate, retaining their source order. It evaluates every input value, so a no-match result is an empty slice."},"source":{"file":"tmuxq/query.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.Where","product":"core","slug":"tmuxq-where"},{"id":"tmuxq.First","name":"First","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"[]T"},{"name":"predicate","type":"func(*T) bool"}],"returns":"(T, bool)","typeParams":["T any"]}],"doc":{"summary":"First returns a shallow copy of the first source-ordered value accepted by predicate and stops evaluating later values. If no value matches, it returns the zero value of T and false."},"source":{"file":"tmuxq/query.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.First","product":"core","slug":"tmuxq-first"},{"id":"tmuxq.ExactlyOne","name":"ExactlyOne","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"[]T"},{"name":"predicate","type":"func(*T) bool"}],"returns":"(T, error)","typeParams":["T any"]}],"doc":{"summary":"ExactlyOne returns a shallow copy when exactly one source-ordered value is accepted by predicate. It examines values until source exhaustion confirms a sole match, or stops at the second match. It returns the zero value of T with [ErrNoMatch] for no matches or [ErrMultipleMatches] for multiple matches; callers can classify either error with [errors.Is]."},"source":{"file":"tmuxq/query.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.ExactlyOne","product":"core","slug":"tmuxq-exactlyone"},{"id":"tmuxq.WhereSeq","name":"WhereSeq","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"iter.Seq[T]"},{"name":"predicate","type":"func(*T) bool"}],"returns":"iter.Seq[T]","typeParams":["T any"]}],"doc":{"summary":"WhereSeq returns a lazy sequence of shallow copies for values accepted by predicate, retaining source order. It does not pull values until the result is iterated. When its consumer stops, WhereSeq stops pulling from values. For an infinite input, it runs until its consumer stops."},"source":{"file":"tmuxq/query.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.WhereSeq","product":"core","slug":"tmuxq-whereseq"},{"id":"tmuxq.FirstSeq","name":"FirstSeq","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"iter.Seq[T]"},{"name":"predicate","type":"func(*T) bool"}],"returns":"(T, bool)","typeParams":["T any"]}],"doc":{"summary":"FirstSeq returns a shallow copy of the first source-ordered sequence value accepted by predicate and stops pulling later values. If no value matches, it returns the zero value of T and false. With an infinite input that never matches, FirstSeq does not return."},"source":{"file":"tmuxq/query.go","line":94,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.FirstSeq","product":"core","slug":"tmuxq-firstseq"},{"id":"tmuxq.ExactlyOneSeq","name":"ExactlyOneSeq","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"iter.Seq[T]"},{"name":"predicate","type":"func(*T) bool"}],"returns":"(T, error)","typeParams":["T any"]}],"doc":{"summary":"ExactlyOneSeq returns a shallow copy when exactly one source-ordered sequence value is accepted by predicate. It stops pulling at the second match. If input ends with no matches, it returns the zero value of T with [ErrNoMatch]; if it finds a second match, it returns the zero value of T with [ErrMultipleMatches]. Callers can classify either error with [errors.Is]. With an infinite input, ExactlyOneSeq returns only after a second match; it cannot confirm a no-match or exactly-one result without source exhaustion."},"source":{"file":"tmuxq/query.go","line":112,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"tmuxq.ExactlyOneSeq","product":"core","slug":"tmuxq-exactlyoneseq"},{"id":"workspace.Workspace.InitialSessionRequest","name":"InitialSessionRequest","kind":"method","modifiers":[],"parent":"workspace.Workspace","signatures":[{"params":[],"returns":"(tmux.NewSessionRequest, error)"}],"doc":{"summary":"InitialSessionRequest validates w and returns the request that creates its session and initial window. Use the resulting materialized session with [BuildInto] to continue the build over a caller-owned transport."},"source":{"file":"workspace/builder.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.InitialSessionRequest","product":"workspace","apiScope":"exported","slug":"workspace-workspace-initialsessionrequest"},{"id":"workspace.Build","name":"Build","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"server","type":"tmux.Server"},{"name":"workspace","type":"Workspace"}],"returns":"(tmux.Session, error)"}],"doc":{"summary":"Build creates the workspace on server and returns the created session.","body":"Build is not atomic. A failure after session creation returns that session;\ncompleted mutations remain in tmux. Command failures are not normalized.\n\nBuild creates the session and an attached control connection in one process,\nuses that connection for the build, and closes it before returning. The\nreturned Session is not bound to the closed connection. Build verifies that\nthe session remains reachable after closing it. An attached connection may\nfire client hooks and policies.\n\nEach pane receives workspace, window, and pane CommandsBefore, then its own\nCommands. Sleep values pause Build rather than the pane."},"source":{"file":"workspace/builder.go","line":41,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Build","product":"workspace","apiScope":"exported","slug":"workspace-build"},{"id":"workspace.BuildInto","name":"BuildInto","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"session","type":"tmux.Session"},{"name":"workspace","type":"Workspace"}],"returns":"error"}],"doc":{"summary":"BuildInto populates the initial session described by workspace. The session must already have been created from [Workspace.InitialSessionRequest]. BuildInto uses the session's existing server and transport; it neither creates a session nor opens or owns a connection.","body":"BuildInto is not atomic. A failure leaves completed mutations in tmux."},"source":{"file":"workspace/builder.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.BuildInto","product":"workspace","apiScope":"exported","slug":"workspace-buildinto"},{"id":"workspace.Command","name":"Command","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Command is one command to run in a pane. YAML accepts either a bare string or a mapping, so \"echo hi\" and {cmd: echo hi, sleep_before: 2} are both commands."},"source":{"file":"workspace/command.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Command","product":"workspace","apiScope":"exported","slug":"workspace-command"},{"id":"workspace.Command.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"workspace.Command","signatures":[],"type":"string","doc":{"summary":"Command is the text typed into the pane."},"source":{"file":"workspace/command.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Command.Command","product":"workspace","apiScope":"exported","slug":"workspace-command-command"},{"id":"workspace.Command.SleepBefore","name":"SleepBefore","kind":"attribute","modifiers":[],"parent":"workspace.Command","signatures":[],"type":"time.Duration","doc":{"summary":"SleepBefore delays this command. YAML expresses the duration in seconds, so 0.5 is half a second."},"source":{"file":"workspace/command.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Command.SleepBefore","product":"workspace","apiScope":"exported","slug":"workspace-command-sleepbefore"},{"id":"workspace.Command.SleepAfter","name":"SleepAfter","kind":"attribute","modifiers":[],"parent":"workspace.Command","signatures":[],"type":"time.Duration","doc":{"summary":"SleepAfter delays the commands that follow this one, in the same units."},"source":{"file":"workspace/command.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Command.SleepAfter","product":"workspace","apiScope":"exported","slug":"workspace-command-sleepafter"},{"id":"workspace.Command.Enter","name":"Enter","kind":"attribute","modifiers":[],"parent":"workspace.Command","signatures":[],"type":"*Bool","doc":{"summary":"Enter reports whether to press Enter after the command. Nil presses it, matching tmuxp, where omitting enter runs the command."},"source":{"file":"workspace/command.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Command.Enter","product":"workspace","apiScope":"exported","slug":"workspace-command-enter"},{"id":"workspace.Command.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Command","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes a command written as a bare string or as a mapping."},"source":{"file":"workspace/command.go","line":29,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Command.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-command-unmarshalyaml"},{"id":"workspace.ErrInvalidWorkspace","name":"ErrInvalidWorkspace","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidWorkspace matches parse and validation failures, but not tmux command failures from [Build]."},"source":{"file":"workspace/workspace.go","line":20,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.ErrInvalidWorkspace","product":"workspace","apiScope":"exported","slug":"workspace-errinvalidworkspace"},{"id":"workspace.Workspace","name":"Workspace","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Workspace is one tmuxp-style session description."},"source":{"file":"workspace/workspace.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace","product":"workspace","apiScope":"exported","slug":"workspace-workspace"},{"id":"workspace.Workspace.SessionName","name":"SessionName","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"string","doc":{"summary":"SessionName names the created session. It is required."},"source":{"file":"workspace/workspace.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.SessionName","product":"workspace","apiScope":"exported","slug":"workspace-workspace-sessionname"},{"id":"workspace.Workspace.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"string","doc":{"summary":"StartDirectory is the default working directory for every window and pane that does not set its own."},"source":{"file":"workspace/workspace.go","line":28,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.StartDirectory","product":"workspace","apiScope":"exported","slug":"workspace-workspace-startdirectory"},{"id":"workspace.Workspace.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is written to the session after its initial pane exists and before later windows are created."},"source":{"file":"workspace/workspace.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.Environment","product":"workspace","apiScope":"exported","slug":"workspace-workspace-environment"},{"id":"workspace.Workspace.Options","name":"Options","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"map[string]string","doc":{"summary":"Options are applied after session creation. tmux resolves window-option names against the session's current window."},"source":{"file":"workspace/workspace.go","line":34,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.Options","product":"workspace","apiScope":"exported","slug":"workspace-workspace-options"},{"id":"workspace.Workspace.GlobalOptions","name":"GlobalOptions","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"map[string]string","doc":{"summary":"GlobalOptions are applied after the initial window exists and before later windows are created."},"source":{"file":"workspace/workspace.go","line":37,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.GlobalOptions","product":"workspace","apiScope":"exported","slug":"workspace-workspace-globaloptions"},{"id":"workspace.Workspace.CommandsBefore","name":"CommandsBefore","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"[]Command","doc":{"summary":"CommandsBefore run in every pane before that pane's own commands. Window and pane entries add to this list rather than replacing it."},"source":{"file":"workspace/workspace.go","line":40,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.CommandsBefore","product":"workspace","apiScope":"exported","slug":"workspace-workspace-commandsbefore"},{"id":"workspace.Workspace.SuppressHistory","name":"SuppressHistory","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"Bool","doc":{"summary":"SuppressHistory prefixes commands with a space unless a window or pane overrides it."},"source":{"file":"workspace/workspace.go","line":43,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.SuppressHistory","product":"workspace","apiScope":"exported","slug":"workspace-workspace-suppresshistory"},{"id":"workspace.Workspace.Windows","name":"Windows","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"[]Window","doc":{"summary":"Windows are created in order. A workspace needs at least one."},"source":{"file":"workspace/workspace.go","line":45,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.Windows","product":"workspace","apiScope":"exported","slug":"workspace-workspace-windows"},{"id":"workspace.Window","name":"Window","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Window is one window in a workspace."},"source":{"file":"workspace/workspace.go","line":49,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window","product":"workspace","apiScope":"exported","slug":"workspace-window"},{"id":"workspace.Window.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"string","doc":{"summary":"Name is the window name. Empty lets tmux choose."},"source":{"file":"workspace/workspace.go","line":51,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.Name","product":"workspace","apiScope":"exported","slug":"workspace-window-name"},{"id":"workspace.Window.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"*int","doc":{"summary":"Index requests an explicit winlink index. Nil uses the next free index."},"source":{"file":"workspace/workspace.go","line":53,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.Index","product":"workspace","apiScope":"exported","slug":"workspace-window-index"},{"id":"workspace.Window.Layout","name":"Layout","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"string","doc":{"summary":"Layout is a tmux layout name applied after the panes exist."},"source":{"file":"workspace/workspace.go","line":55,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.Layout","product":"workspace","apiScope":"exported","slug":"workspace-window-layout"},{"id":"workspace.Window.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"string","doc":{"summary":"StartDirectory overrides the workspace directory for this window."},"source":{"file":"workspace/workspace.go","line":57,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.StartDirectory","product":"workspace","apiScope":"exported","slug":"workspace-window-startdirectory"},{"id":"workspace.Window.Shell","name":"Shell","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"string","doc":{"summary":"Shell replaces the command the window's first pane runs."},"source":{"file":"workspace/workspace.go","line":59,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.Shell","product":"workspace","apiScope":"exported","slug":"workspace-window-shell"},{"id":"workspace.Window.Focus","name":"Focus","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"Bool","doc":{"summary":"Focus selects this window once the workspace is built."},"source":{"file":"workspace/workspace.go","line":61,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.Focus","product":"workspace","apiScope":"exported","slug":"workspace-window-focus"},{"id":"workspace.Window.SuppressHistory","name":"SuppressHistory","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"*Bool","doc":{"summary":"SuppressHistory overrides the workspace setting for this window's panes."},"source":{"file":"workspace/workspace.go","line":63,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.SuppressHistory","product":"workspace","apiScope":"exported","slug":"workspace-window-suppresshistory"},{"id":"workspace.Window.Options","name":"Options","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"map[string]string","doc":{"summary":"Options are applied after the window's initial pane exists and before additional panes are split."},"source":{"file":"workspace/workspace.go","line":66,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.Options","product":"workspace","apiScope":"exported","slug":"workspace-window-options"},{"id":"workspace.Window.OptionsAfter","name":"OptionsAfter","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"map[string]string","doc":{"summary":"OptionsAfter are window options applied once the panes exist, for settings that a later split would otherwise overwrite."},"source":{"file":"workspace/workspace.go","line":69,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.OptionsAfter","product":"workspace","apiScope":"exported","slug":"workspace-window-optionsafter"},{"id":"workspace.Window.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is written to the session after this window's initial pane exists and before additional panes are split. Repeated names keep the last value written."},"source":{"file":"workspace/workspace.go","line":73,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.Environment","product":"workspace","apiScope":"exported","slug":"workspace-window-environment"},{"id":"workspace.Window.CommandsBefore","name":"CommandsBefore","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"[]Command","doc":{"summary":"CommandsBefore run in each of this window's panes before the pane's own commands, after the workspace's."},"source":{"file":"workspace/workspace.go","line":76,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.CommandsBefore","product":"workspace","apiScope":"exported","slug":"workspace-window-commandsbefore"},{"id":"workspace.Window.Panes","name":"Panes","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"[]Pane","doc":{"summary":"Panes are created in order. The first pane is the window's initial pane; each later one splits the window."},"source":{"file":"workspace/workspace.go","line":79,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.Panes","product":"workspace","apiScope":"exported","slug":"workspace-window-panes"},{"id":"workspace.Pane","name":"Pane","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Pane is one pane in a window. YAML accepts either a bare command string or a mapping, so \"echo hello\" and {shell_command: echo hello} are equivalent."},"source":{"file":"workspace/workspace.go","line":86,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane","product":"workspace","apiScope":"exported","slug":"workspace-pane"},{"id":"workspace.Pane.Commands","name":"Commands","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"[]Command","doc":{"summary":"Commands run in the pane, in order."},"source":{"file":"workspace/workspace.go","line":88,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.Commands","product":"workspace","apiScope":"exported","slug":"workspace-pane-commands"},{"id":"workspace.Pane.CommandsBefore","name":"CommandsBefore","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"[]Command","doc":{"summary":"CommandsBefore run before Commands, after the window's."},"source":{"file":"workspace/workspace.go","line":90,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.CommandsBefore","product":"workspace","apiScope":"exported","slug":"workspace-pane-commandsbefore"},{"id":"workspace.Pane.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"string","doc":{"summary":"StartDirectory overrides the window directory for this pane."},"source":{"file":"workspace/workspace.go","line":92,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.StartDirectory","product":"workspace","apiScope":"exported","slug":"workspace-pane-startdirectory"},{"id":"workspace.Pane.Shell","name":"Shell","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"string","doc":{"summary":"Shell replaces this pane's command. On the first pane it conflicts with Window.Shell because tmux creates that pane with the window."},"source":{"file":"workspace/workspace.go","line":95,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.Shell","product":"workspace","apiScope":"exported","slug":"workspace-pane-shell"},{"id":"workspace.Pane.Focus","name":"Focus","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"Bool","doc":{"summary":"Focus selects this pane once its window is built."},"source":{"file":"workspace/workspace.go","line":97,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.Focus","product":"workspace","apiScope":"exported","slug":"workspace-pane-focus"},{"id":"workspace.Pane.SuppressHistory","name":"SuppressHistory","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"*Bool","doc":{"summary":"SuppressHistory overrides the window setting for this pane."},"source":{"file":"workspace/workspace.go","line":99,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.SuppressHistory","product":"workspace","apiScope":"exported","slug":"workspace-pane-suppresshistory"},{"id":"workspace.Pane.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is written to the session after all panes in the window exist and before this pane's commands are sent. Pane entries are processed in order, so repeated names keep the last value written."},"source":{"file":"workspace/workspace.go","line":103,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.Environment","product":"workspace","apiScope":"exported","slug":"workspace-pane-environment"},{"id":"workspace.Pane.Enter","name":"Enter","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"*Bool","doc":{"summary":"Enter applies to every command in this pane unless the command sets its own. Nil presses Enter, matching tmuxp."},"source":{"file":"workspace/workspace.go","line":106,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.Enter","product":"workspace","apiScope":"exported","slug":"workspace-pane-enter"},{"id":"workspace.Pane.SleepBefore","name":"SleepBefore","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"time.Duration","doc":{"summary":"SleepBefore delays before each of this pane's commands. YAML writes it as a number of seconds, matching tmuxp, so 0.5 is half a second."},"source":{"file":"workspace/workspace.go","line":109,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.SleepBefore","product":"workspace","apiScope":"exported","slug":"workspace-pane-sleepbefore"},{"id":"workspace.Pane.SleepAfter","name":"SleepAfter","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"time.Duration","doc":{"summary":"SleepAfter delays after each of this pane's commands, in the same units."},"source":{"file":"workspace/workspace.go","line":111,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.SleepAfter","product":"workspace","apiScope":"exported","slug":"workspace-pane-sleepafter"},{"id":"workspace.Bool","name":"Bool","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Bool accepts YAML booleans and tmuxp's quoted spellings. It is exported so callers can construct optional *Bool fields."},"source":{"file":"workspace/workspace.go","line":116,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Bool","product":"workspace","apiScope":"exported","slug":"workspace-bool"},{"id":"workspace.Bool.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Bool","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes a boolean written as a boolean or as a string."},"source":{"file":"workspace/workspace.go","line":119,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Bool.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-bool-unmarshalyaml"},{"id":"workspace.Workspace.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Workspace","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes the workspace, then its shell_command_before, which accepts one command or a list."},"source":{"file":"workspace/workspace.go","line":142,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-workspace-unmarshalyaml"},{"id":"workspace.Window.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Window","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes the window, then its shell_command_before."},"source":{"file":"workspace/workspace.go","line":167,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Window.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-window-unmarshalyaml"},{"id":"workspace.Pane.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Pane","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes a pane written as a bare command or as a mapping."},"source":{"file":"workspace/workspace.go","line":194,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Pane.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-pane-unmarshalyaml"},{"id":"workspace.Parse","name":"Parse","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"document","type":"[]byte"}],"returns":"(Workspace, error)"}],"doc":{"summary":"Parse decodes one workspace document. Unknown fields are rejected so a misspelled key fails loudly instead of being dropped."},"source":{"file":"workspace/workspace.go","line":251,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Parse","product":"workspace","apiScope":"exported","slug":"workspace-parse"},{"id":"workspace.Workspace.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"workspace.Workspace","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate reports all problems joined under [ErrInvalidWorkspace]."},"source":{"file":"workspace/workspace.go","line":266,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.Validate","product":"workspace","apiScope":"exported","slug":"workspace-workspace-validate"},{"id":"workspace.Workspace.MissingDirectories","name":"MissingDirectories","kind":"method","modifiers":[],"parent":"workspace.Workspace","signatures":[{"params":[],"returns":"[]string"}],"doc":{"summary":"MissingDirectories returns absent start directories in document order. It is separate from [Workspace.Validate] because a prior command may create them. tmux otherwise falls back to the user's home directory without an error. Names beginning with ~ are resolved as tmux resolves them."},"source":{"file":"workspace/workspace.go","line":419,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"workspace.Workspace.MissingDirectories","product":"workspace","apiScope":"exported","slug":"workspace-workspace-missingdirectories"},{"id":"mcp.AuditEnvironmentVariable","name":"AuditEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"AuditEnvironmentVariable names the variable that turns the record on and says where it goes: \"stderr\", or a path to append to."},"source":{"file":"mcp/audit.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.AuditEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-auditenvironmentvariable"},{"id":"mcp.HandshakeOrdered","name":"HandshakeOrdered","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"inner","type":"mcp.Transport"}],"returns":"mcp.Transport"}],"doc":{"summary":"HandshakeOrdered holds the SDK's early tool-list notification until notifications/initialized; strict legacy clients reject the earlier ordering."},"source":{"file":"mcp/handshake_transport.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.HandshakeOrdered","product":"mcp","apiScope":"exported","slug":"mcp-handshakeordered"},{"id":"mcp.ErrInstanceClosed","name":"ErrInstanceClosed","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInstanceClosed identifies work refused after instance shutdown starts."},"source":{"file":"mcp/instance.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ErrInstanceClosed","product":"mcp","apiScope":"exported","slug":"mcp-errinstanceclosed"},{"id":"mcp.ErrRequestCapacity","name":"ErrRequestCapacity","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrRequestCapacity identifies a client session closed after it exceeded the server's finite unsettled-call capacity."},"source":{"file":"mcp/instance.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ErrRequestCapacity","product":"mcp","apiScope":"exported","slug":"mcp-errrequestcapacity"},{"id":"mcp.Instance","name":"Instance","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Instance owns the SDK server, all connected client sessions, and every resource allocated on their behalf. The SDK server is composed so Connect and Run cannot bypass lifecycle tracking."},"source":{"file":"mcp/instance.go","line":30,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.Instance","product":"mcp","apiScope":"exported","slug":"mcp-instance"},{"id":"mcp.ServerSession","name":"ServerSession","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerSession owns one SDK session and the resources scoped to its client."},"source":{"file":"mcp/instance.go","line":70,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ServerSession","product":"mcp","apiScope":"exported","slug":"mcp-serversession"},{"id":"mcp.Instance.Connect","name":"Connect","kind":"method","modifiers":[],"parent":"mcp.Instance","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"transport","type":"sdk.Transport"},{"name":"options","type":"*sdk.ServerSessionOptions"}],"returns":"(*ServerSession, error)"}],"doc":{"summary":"Connect starts and tracks one client session. It requires tmux 3.2a or newer and rejects an opaque transport unless [AssumeResponseCommit] marks its response-write contract. Incoming messages remain gated until the SDK session has an installed scope."},"source":{"file":"mcp/instance_connect.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.Instance.Connect","product":"mcp","apiScope":"exported","slug":"mcp-instance-connect"},{"id":"mcp.Instance.Run","name":"Run","kind":"method","modifiers":[],"parent":"mcp.Instance","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"transport","type":"sdk.Transport"}],"returns":"error"}],"doc":{"summary":"Run serves one tracked session until the client, context, or instance ends. Its transport requirements are the same as [Instance.Connect]."},"source":{"file":"mcp/instance_connect.go","line":102,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.Instance.Run","product":"mcp","apiScope":"exported","slug":"mcp-instance-run"},{"id":"mcp.Instance.Close","name":"Close","kind":"method","modifiers":[],"parent":"mcp.Instance","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close starts shutdown and waits on a bounded internal context."},"source":{"file":"mcp/instance_lifecycle.go","line":13,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.Instance.Close","product":"mcp","apiScope":"exported","slug":"mcp-instance-close"},{"id":"mcp.Instance.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"mcp.Instance","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts shutdown unconditionally. ctx bounds only this call's wait; a later call can resume waiting for the same shutdown."},"source":{"file":"mcp/instance_lifecycle.go","line":24,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.Instance.CloseContext","product":"mcp","apiScope":"exported","slug":"mcp-instance-closecontext"},{"id":"mcp.ServerSession.Close","name":"Close","kind":"method","modifiers":[],"parent":"mcp.ServerSession","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops scoped work, closes the transport, and joins SDK session cleanup."},"source":{"file":"mcp/instance_lifecycle.go","line":128,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ServerSession.Close","product":"mcp","apiScope":"exported","slug":"mcp-serversession-close"},{"id":"mcp.ServerSession.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"mcp.ServerSession","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Wait waits for client termination and session cleanup."},"source":{"file":"mcp/instance_lifecycle.go","line":143,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ServerSession.Wait","product":"mcp","apiScope":"exported","slug":"mcp-serversession-wait"},{"id":"mcp.MaterializeMinimalConfig","name":"MaterializeMinimalConfig","kind":"function","modifiers":[],"signatures":[{"params":[],"returns":"(string, func() error, error)"}],"doc":{"summary":"MaterializeMinimalConfig writes the embedded dedicated-server configuration for tmux's -f option. The caller keeps it until the MCP process stops."},"source":{"file":"mcp/minimal_config.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.MaterializeMinimalConfig","product":"mcp","apiScope":"exported","slug":"mcp-materializeminimalconfig"},{"id":"mcp.CapabilitiesResourceURI","name":"CapabilitiesResourceURI","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"CapabilitiesResourceURI is the only MCP resource exposed by this server."},"source":{"file":"mcp/resources.go","line":11,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.CapabilitiesResourceURI","product":"mcp","apiScope":"exported","slug":"mcp-capabilitiesresourceuri"},{"id":"mcp.ErrResponseCommitUnknown","name":"ErrResponseCommitUnknown","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrResponseCommitUnknown identifies a transport whose successful Write may leave one response buffered behind another response in a JSON-RPC batch."},"source":{"file":"mcp/response_transport.go","line":15,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ErrResponseCommitUnknown","product":"mcp","apiScope":"exported","slug":"mcp-errresponsecommitunknown"},{"id":"mcp.AssumeResponseCommit","name":"AssumeResponseCommit","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"transport","type":"mcp.Transport"}],"returns":"mcp.Transport"}],"doc":{"summary":"AssumeResponseCommit marks transport as committing each response before its Connection.Write returns nil. It does not change transport behavior. Use it only for a transport that rejects JSON-RPC batches or writes every response independently; direct IO and stdio transports are handled automatically."},"source":{"file":"mcp/response_transport.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.AssumeResponseCommit","product":"mcp","apiScope":"exported","slug":"mcp-assumeresponsecommit"},{"id":"mcp.ErrRuntimeTargetBound","name":"ErrRuntimeTargetBound","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrRuntimeTargetBound identifies a target already bound to a terminal Connection. An MCP runtime must own the connection it creates."},"source":{"file":"mcp/runtime.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ErrRuntimeTargetBound","product":"mcp","apiScope":"exported","slug":"mcp-errruntimetargetbound"},{"id":"mcp.Version","name":"Version","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"Version is reported during MCP initialization. Installed binaries derive it from build metadata; source builds use fallbackVersion."},"source":{"file":"mcp/server.go","line":22,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.Version","product":"mcp","apiScope":"exported","slug":"mcp-version"},{"id":"mcp.NewServer","name":"NewServer","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"target","type":"tmux.Server"}],"returns":"(*Instance, error)"}],"doc":{"summary":"NewServer returns a closeable MCP instance exposing target. It rejects an invalid target before allocating instance-owned resources."},"source":{"file":"mcp/server.go","line":144,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.NewServer","product":"mcp","apiScope":"exported","slug":"mcp-newserver"},{"id":"mcp.Run","name":"Run","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"target","type":"tmux.Server"}],"returns":"error"}],"doc":{"summary":"Run serves target over stdin and stdout until ctx is done."},"source":{"file":"mcp/server.go","line":251,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.Run","product":"mcp","apiScope":"exported","slug":"mcp-run"},{"id":"mcp.RunDefaultMinimal","name":"RunDefaultMinimal","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"target","type":"tmux.Server"}],"returns":"error"}],"doc":{"summary":"RunDefaultMinimal serves a package-created default dedicated target. It starts or joins the daemon with a one-use owner marker and grants default teardown only when the marker proves this process created that daemon."},"source":{"file":"mcp/server.go","line":285,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.RunDefaultMinimal","product":"mcp","apiScope":"exported","slug":"mcp-rundefaultminimal"},{"id":"mcp.AdvertisedTools","name":"AdvertisedTools","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]*sdk.Tool, error)"}],"doc":{"summary":"AdvertisedTools returns caller-owned descriptions of the startup-selected tools. It performs an in-memory MCP handshake without opening tmux or allocating runtime-owned audit resources.","body":"It describes a server that creates the default dedicated tmux server, the\nwidest default surface. [AdvertisedToolsFor] answers for a specific target."},"source":{"file":"mcp/tool_catalog.go","line":19,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.AdvertisedTools","product":"mcp","apiScope":"exported","slug":"mcp-advertisedtools"},{"id":"mcp.AdvertisedToolsFor","name":"AdvertisedToolsFor","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"target","type":"tmux.Server"},{"name":"defaultMinimal","type":"bool"}],"returns":"([]*sdk.Tool, error)"}],"doc":{"summary":"AdvertisedToolsFor returns the tools a server started now against target would advertise. defaultMinimal selects [RunDefaultMinimal]'s rule, which grants teardown tools only when that server creates the tmux server, so only when none is answering yet; [Run] never grants them by default. It asks whether a tmux server is answering and starts nothing."},"source":{"file":"mcp/tool_catalog.go","line":36,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.AdvertisedToolsFor","product":"mcp","apiScope":"exported","slug":"mcp-advertisedtoolsfor"},{"id":"mcp.ToolDetails","name":"ToolDetails","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(string, bool)"}],"doc":{"summary":"ToolDetails returns what the named tool does, without the capability disclosure every description opens with. The disclosure is shared across a toolset, so a listing that shows only a description's first sentence would otherwise show the same sentence for every tool in it."},"source":{"file":"mcp/tool_catalog.go","line":102,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ToolDetails","product":"mcp","apiScope":"exported","slug":"mcp-tooldetails"},{"id":"mcp.CapabilityMetaKey","name":"CapabilityMetaKey","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"CapabilityMetaKey is the MCP metadata key carrying the complete capability row that also drives registration and tmux://capabilities."},"source":{"file":"mcp/tool_manifest.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.CapabilityMetaKey","product":"mcp","apiScope":"exported","slug":"mcp-capabilitymetakey"},{"id":"mcp.SocketEnvironmentVariable","name":"SocketEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"SocketEnvironmentVariable selects one named tmux socket."},"source":{"file":"mcp/tool_surface.go","line":12,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.SocketEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-socketenvironmentvariable"},{"id":"mcp.SocketPathEnvironmentVariable","name":"SocketPathEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"SocketPathEnvironmentVariable selects one absolute tmux socket path."},"source":{"file":"mcp/tool_surface.go","line":14,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.SocketPathEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-socketpathenvironmentvariable"},{"id":"mcp.TmuxConfigEnvironmentVariable","name":"TmuxConfigEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"TmuxConfigEnvironmentVariable selects an absolute tmux config path."},"source":{"file":"mcp/tool_surface.go","line":16,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.TmuxConfigEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-tmuxconfigenvironmentvariable"},{"id":"mcp.BinaryEnvironmentVariable","name":"BinaryEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"BinaryEnvironmentVariable selects the tmux executable."},"source":{"file":"mcp/tool_surface.go","line":18,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.BinaryEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-binaryenvironmentvariable"},{"id":"mcp.ToolsetsEnvironmentVariable","name":"ToolsetsEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ToolsetsEnvironmentVariable selects unordered inspect, manage, execute, and teardown groups. A present empty value selects no groups."},"source":{"file":"mcp/tool_surface.go","line":21,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ToolsetsEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-toolsetsenvironmentvariable"},{"id":"mcp.ToolsEnvironmentVariable","name":"ToolsEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ToolsEnvironmentVariable adds exact tool names after toolset expansion."},"source":{"file":"mcp/tool_surface.go","line":23,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ToolsEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-toolsenvironmentvariable"},{"id":"mcp.ExcludeToolsEnvironmentVariable","name":"ExcludeToolsEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ExcludeToolsEnvironmentVariable removes exact names after every inclusion."},"source":{"file":"mcp/tool_surface.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.ExcludeToolsEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-excludetoolsenvironmentvariable"},{"id":"mcp.SafetyEnvironmentVariable","name":"SafetyEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"SafetyEnvironmentVariable is rejected because ordered safety tiers were retired."},"source":{"file":"mcp/tool_surface.go","line":27,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.SafetyEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-safetyenvironmentvariable"},{"id":"mcp.RecipeToolEnvironmentVariable","name":"RecipeToolEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"RecipeToolEnvironmentVariable is rejected because prompt exports were retired."},"source":{"file":"mcp/tool_surface.go","line":31,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.RecipeToolEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-recipetoolenvironmentvariable"},{"id":"mcp.WaitCeilingEnvironmentVariable","name":"WaitCeilingEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"WaitCeilingEnvironmentVariable names the variable that raises or lowers the longest wait this server will run, in seconds. It matches the Python server so an operator configuring both writes one thing."},"source":{"file":"mcp/wait_tools.go","line":25,"repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},"publicId":"mcp.WaitCeilingEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-waitceilingenvironmentvariable"}],"pruned":{"dropped":73,"kept":2816,"rules":["/^internal\\./","/^tmux\\.internal\\./"]},"sources":[{"product":"core","package":"github.com/libtmux/libtmux-go/tmux","repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},{"product":"workspace","package":"github.com/libtmux/libtmux-go/workspace","repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"},{"product":"mcp","package":"github.com/libtmux/libtmux-go/mcp","repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","extractedRevision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0"}],"repo":"libtmux/libtmux-go"}
+{"port":"go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractor":"@libtmux/api-model@0.0.1","symbols":[{"id":"tmux.ModulePath","name":"ModulePath","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ModulePath is the Go module this package belongs to. It is the module path rather than the package path, because that is what Go build metadata records."},"source":{"file":"tmux/build_info.go","line":7,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ModulePath","product":"core","slug":"tmux-modulepath"},{"id":"tmux.PackageVersion","name":"PackageVersion","kind":"function","modifiers":[],"signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PackageVersion returns the release version recorded in Go build metadata. Development builds and binaries without module metadata return \"\", false."},"source":{"file":"tmux/build_info.go","line":11,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PackageVersion","product":"core","slug":"tmux-packageversion"},{"id":"tmux.ClientAttachment","name":"ClientAttachment","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClientAttachment is one immutable view of a client's live attachment. Session, Window, and Pane return values from the same observational Snapshot."},"source":{"file":"tmux/client_attachment.go","line":10,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientAttachment","product":"core","slug":"tmux-clientattachment"},{"id":"tmux.ClientAttachment.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.ClientAttachment","signatures":[{"params":[],"returns":"(Session, bool)"}],"doc":{"summary":"Session returns the attached session, if it remained live in the snapshot."},"source":{"file":"tmux/client_attachment.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientAttachment.Session","product":"core","slug":"tmux-clientattachment-session"},{"id":"tmux.ClientAttachment.Window","name":"Window","kind":"method","modifiers":[],"parent":"tmux.ClientAttachment","signatures":[{"params":[],"returns":"(Window, bool)"}],"doc":{"summary":"Window returns the attached session's active winlink, if present."},"source":{"file":"tmux/client_attachment.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientAttachment.Window","product":"core","slug":"tmux-clientattachment-window"},{"id":"tmux.ClientAttachment.Pane","name":"Pane","kind":"method","modifiers":[],"parent":"tmux.ClientAttachment","signatures":[{"params":[],"returns":"(Pane, bool)"}],"doc":{"summary":"Pane returns the attached session's active window's active pane, if present."},"source":{"file":"tmux/client_attachment.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientAttachment.Pane","product":"core","slug":"tmux-clientattachment-pane"},{"id":"tmux.Client.ResolveAttachment","name":"ResolveAttachment","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ClientAttachment, error)"}],"doc":{"summary":"ResolveAttachment re-reads the client's live attached hierarchy.","body":"One resolution materializes one strict Snapshot. Snapshot collection is a\nmulti-command observational read, so concurrent tmux changes may produce a\npartial hierarchy. A missing client, detached client, or stale session\nreturns an empty attachment without an error. Other collection, decoding,\nand cardinality errors remain visible."},"source":{"file":"tmux/client_attachment.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.ResolveAttachment","product":"core","slug":"tmux-client-resolveattachment"},{"id":"tmux.ErrUnknownColor","name":"ErrUnknownColor","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrUnknownColor identifies an unsupported tmux color mode. It is matched by errors.Is for [ColorError]."},"source":{"file":"tmux/command.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrUnknownColor","product":"core","slug":"tmux-errunknowncolor"},{"id":"tmux.ErrCommand","name":"ErrCommand","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrCommand identifies a failed high-level tmux command. It is matched by errors.Is for [CommandError]."},"source":{"file":"tmux/command.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrCommand","product":"core","slug":"tmux-errcommand"},{"id":"tmux.ErrNoServer","name":"ErrNoServer","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrNoServer identifies a command that no tmux server answered. A [CommandError] may match both ErrNoServer and [ErrCommand]. tmux cannot reliably distinguish an absent or unreachable server from one that exited during the command."},"source":{"file":"tmux/command.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrNoServer","product":"core","slug":"tmux-errnoserver"},{"id":"tmux.ErrNotFound","name":"ErrNotFound","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrNotFound identifies an operation naming a tmux object that does not exist. A lookup that found nothing matches it, and so does a command tmux refused because the target it named was gone — the same condition reached from either direction. [SnapshotLookupError] and [CommandError] match it through errors.Is.","body":"Only a claim of absence this package has not disproved matches. A lookup\nthat reaches a replaced daemon, or whose diagnostic names an object it did\nnot target, reports what it saw rather than an absence."},"source":{"file":"tmux/command.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrNotFound","product":"core","slug":"tmux-errnotfound"},{"id":"tmux.ColorMode","name":"ColorMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ColorMode selects a tmux color-capability override for [ServerOptions]."},"source":{"file":"tmux/command.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ColorMode","product":"core","slug":"tmux-colormode"},{"id":"tmux.ColorDefault","name":"ColorDefault","kind":"constant","modifiers":[],"signatures":[],"type":"ColorMode","doc":{"summary":"ColorDefault preserves tmux's detected color capability."},"source":{"file":"tmux/command.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ColorDefault","product":"core","slug":"tmux-colordefault"},{"id":"tmux.Color256","name":"Color256","kind":"constant","modifiers":[],"signatures":[],"type":"ColorMode","doc":{"summary":"Color256 requests tmux's 256-color capability mode."},"source":{"file":"tmux/command.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Color256","product":"core","slug":"tmux-color256"},{"id":"tmux.ColorError","name":"ColorError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ColorError reports an unsupported color mode. It matches [ErrUnknownColor] through errors.Is; callers can recover Mode with errors.As."},"source":{"file":"tmux/command.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ColorError","product":"core","slug":"tmux-colorerror"},{"id":"tmux.ColorError.Mode","name":"Mode","kind":"attribute","modifiers":[],"parent":"tmux.ColorError","signatures":[],"type":"ColorMode","doc":{"summary":"Mode is the rejected color-capability override."},"source":{"file":"tmux/command.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ColorError.Mode","product":"core","slug":"tmux-colorerror-mode"},{"id":"tmux.ColorError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ColorError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/command.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ColorError.Error","product":"core","slug":"tmux-colorerror-error"},{"id":"tmux.ColorError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ColorError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ColorError compatible with ErrUnknownColor."},"source":{"file":"tmux/command.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ColorError.Unwrap","product":"core","slug":"tmux-colorerror-unwrap"},{"id":"tmux.CommandResult","name":"CommandResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandResult contains one completed tmux invocation. [Server.Cmd] returns it even when tmux exits nonzero. Library operations clone its slices before returning it, so the caller owns Command, Stdout, RawStdout, and Stderr."},"source":{"file":"tmux/command.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandResult","product":"core","slug":"tmux-commandresult"},{"id":"tmux.CommandResult.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"[]string","doc":{"summary":"Command is the executed tmux argument vector."},"source":{"file":"tmux/command.go","line":72,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandResult.Command","product":"core","slug":"tmux-commandresult-command"},{"id":"tmux.CommandResult.Stdout","name":"Stdout","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"[]string","doc":{"summary":"Stdout contains one decoded standard-output line per element."},"source":{"file":"tmux/command.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandResult.Stdout","product":"core","slug":"tmux-commandresult-stdout"},{"id":"tmux.CommandResult.RawStdout","name":"RawStdout","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"[]byte","doc":{"summary":"RawStdout contains exact captured standard-output bytes, including line delimiters and trailing newlines. It is nil when no output was captured."},"source":{"file":"tmux/command.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandResult.RawStdout","product":"core","slug":"tmux-commandresult-rawstdout"},{"id":"tmux.CommandResult.Stderr","name":"Stderr","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"[]string","doc":{"summary":"Stderr contains one decoded standard-error line per element."},"source":{"file":"tmux/command.go","line":79,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandResult.Stderr","product":"core","slug":"tmux-commandresult-stderr"},{"id":"tmux.CommandResult.ExitCode","name":"ExitCode","kind":"attribute","modifiers":[],"parent":"tmux.CommandResult","signatures":[],"type":"int","doc":{"summary":"ExitCode is tmux's completed process exit code, or -1 when no tmux command ran: this package refused the request, or a transport failed before tmux answered. A negative code is therefore never tmux's opinion of the request, and an error carrying one has a reason of its own."},"source":{"file":"tmux/command.go","line":84,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandResult.ExitCode","product":"core","slug":"tmux-commandresult-exitcode"},{"id":"tmux.CommandError","name":"CommandError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandError reports a completed failed high-level tmux operation. It matches [ErrCommand] through errors.Is; callers can recover its fields with errors.As. Generic library operations retain an owned copy of the completed command and output so tmux diagnostics remain available. Operations whose primary payload may contain secrets return an exit-code-only result instead. Callers must treat retained argv and output as potentially sensitive."},"source":{"file":"tmux/command.go","line":119,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandError","product":"core","slug":"tmux-commanderror"},{"id":"tmux.CommandError.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.CommandError","signatures":[],"type":"string","doc":{"summary":"Subcommand is the failed tmux subcommand."},"source":{"file":"tmux/command.go","line":121,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandError.Subcommand","product":"core","slug":"tmux-commanderror-subcommand"},{"id":"tmux.CommandError.Result","name":"Result","kind":"attribute","modifiers":[],"parent":"tmux.CommandError","signatures":[],"type":"CommandResult","doc":{"summary":"Result is the owned completed result, or an exit-code-only redacted result for a secret-bearing operation."},"source":{"file":"tmux/command.go","line":124,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandError.Result","product":"core","slug":"tmux-commanderror-result"},{"id":"tmux.CommandError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.CommandError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/command.go","line":131,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandError.Error","product":"core","slug":"tmux-commanderror-error"},{"id":"tmux.CommandError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.CommandError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes CommandError compatible with ErrCommand."},"source":{"file":"tmux/command.go","line":140,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandError.Unwrap","product":"core","slug":"tmux-commanderror-unwrap"},{"id":"tmux.CommandError.Is","name":"Is","kind":"method","modifiers":[],"parent":"tmux.CommandError","signatures":[{"params":[{"name":"target","type":"error"}],"returns":"bool"}],"doc":{"summary":"Is reports [ErrNoServer] for a failure that means no tmux server answered — either the command never reached one, or the one it reached is gone — and [ErrNotFound] for one tmux refused because the object it named was absent."},"source":{"file":"tmux/command.go","line":147,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandError.Is","product":"core","slug":"tmux-commanderror-is"},{"id":"tmux.ErrMalformedComplexOption","name":"ErrMalformedComplexOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedComplexOption identifies an invalid entry in a parsed complex option."},"source":{"file":"tmux/complex_options.go","line":11,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrMalformedComplexOption","product":"core","slug":"tmux-errmalformedcomplexoption"},{"id":"tmux.ComplexOptionDecodeError","name":"ComplexOptionDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ComplexOptionDecodeError identifies one malformed sparse-array entry without retaining its raw value."},"source":{"file":"tmux/complex_options.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ComplexOptionDecodeError","product":"core","slug":"tmux-complexoptiondecodeerror"},{"id":"tmux.ComplexOptionDecodeError.Option","name":"Option","kind":"attribute","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[],"type":"string","doc":{"summary":"Option is the option name whose sparse-array entry was malformed."},"source":{"file":"tmux/complex_options.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ComplexOptionDecodeError.Option","product":"core","slug":"tmux-complexoptiondecodeerror-option"},{"id":"tmux.ComplexOptionDecodeError.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[],"type":"int","doc":{"summary":"Index is the zero-based sparse-array entry index."},"source":{"file":"tmux/complex_options.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ComplexOptionDecodeError.Index","product":"core","slug":"tmux-complexoptiondecodeerror-index"},{"id":"tmux.ComplexOptionDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes the syntax failure without retaining raw option contents."},"source":{"file":"tmux/complex_options.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ComplexOptionDecodeError.Reason","product":"core","slug":"tmux-complexoptiondecodeerror-reason"},{"id":"tmux.ComplexOptionDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/complex_options.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ComplexOptionDecodeError.Error","product":"core","slug":"tmux-complexoptiondecodeerror-error"},{"id":"tmux.ComplexOptionDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ComplexOptionDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ComplexOptionDecodeError compatible with ErrMalformedComplexOption."},"source":{"file":"tmux/complex_options.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ComplexOptionDecodeError.Unwrap","product":"core","slug":"tmux-complexoptiondecodeerror-unwrap"},{"id":"tmux.CommandAlias","name":"CommandAlias","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandAlias is one parsed command-alias entry."},"source":{"file":"tmux/complex_options.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandAlias","product":"core","slug":"tmux-commandalias"},{"id":"tmux.CommandAlias.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.CommandAlias","signatures":[],"type":"string","doc":{"summary":"Name is the alias name."},"source":{"file":"tmux/complex_options.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandAlias.Name","product":"core","slug":"tmux-commandalias-name"},{"id":"tmux.CommandAlias.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.CommandAlias","signatures":[],"type":"string","doc":{"summary":"Command is the tmux command text associated with Name."},"source":{"file":"tmux/complex_options.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandAlias.Command","product":"core","slug":"tmux-commandalias-command"},{"id":"tmux.CommandAliases","name":"CommandAliases","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandAliases is an immutable parsed command-alias option. Its zero value is an empty collection: Len is zero, Lookup reports false, and Entries returns a nonnil empty slice."},"source":{"file":"tmux/complex_options.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandAliases","product":"core","slug":"tmux-commandaliases"},{"id":"tmux.CommandAliases.Lookup","name":"Lookup","kind":"method","modifiers":[],"parent":"tmux.CommandAliases","signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(string, bool)"}],"doc":{"summary":"Lookup returns the command registered for name."},"source":{"file":"tmux/complex_options.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandAliases.Lookup","product":"core","slug":"tmux-commandaliases-lookup"},{"id":"tmux.CommandAliases.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.CommandAliases","signatures":[{"params":[],"returns":"[]CommandAlias"}],"doc":{"summary":"Entries returns a fresh slice in first-definition order."},"source":{"file":"tmux/complex_options.go","line":64,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandAliases.Entries","product":"core","slug":"tmux-commandaliases-entries"},{"id":"tmux.CommandAliases.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.CommandAliases","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of distinct aliases."},"source":{"file":"tmux/complex_options.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandAliases.Len","product":"core","slug":"tmux-commandaliases-len"},{"id":"tmux.TerminalFeature","name":"TerminalFeature","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalFeature is one terminal pattern and its enabled features."},"source":{"file":"tmux/complex_options.go","line":72,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalFeature","product":"core","slug":"tmux-terminalfeature"},{"id":"tmux.TerminalFeature.Terminal","name":"Terminal","kind":"attribute","modifiers":[],"parent":"tmux.TerminalFeature","signatures":[],"type":"string","doc":{"summary":"Terminal is the terminal pattern."},"source":{"file":"tmux/complex_options.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalFeature.Terminal","product":"core","slug":"tmux-terminalfeature-terminal"},{"id":"tmux.TerminalFeature.Features","name":"Features","kind":"attribute","modifiers":[],"parent":"tmux.TerminalFeature","signatures":[],"type":"[]string","doc":{"summary":"Features is an owned feature list for Terminal."},"source":{"file":"tmux/complex_options.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalFeature.Features","product":"core","slug":"tmux-terminalfeature-features"},{"id":"tmux.TerminalFeatures","name":"TerminalFeatures","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalFeatures is an immutable parsed terminal-features option. Its zero value is an empty collection: Len is zero, Lookup reports false, and Entries returns a nonnil empty slice."},"source":{"file":"tmux/complex_options.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalFeatures","product":"core","slug":"tmux-terminalfeatures"},{"id":"tmux.TerminalFeatures.Lookup","name":"Lookup","kind":"method","modifiers":[],"parent":"tmux.TerminalFeatures","signatures":[{"params":[{"name":"terminal","type":"string"}],"returns":"([]string, bool)"}],"doc":{"summary":"Lookup returns a fresh feature slice for terminal."},"source":{"file":"tmux/complex_options.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalFeatures.Lookup","product":"core","slug":"tmux-terminalfeatures-lookup"},{"id":"tmux.TerminalFeatures.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.TerminalFeatures","signatures":[{"params":[],"returns":"[]TerminalFeature"}],"doc":{"summary":"Entries returns a deep fresh copy in first-definition order."},"source":{"file":"tmux/complex_options.go","line":97,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalFeatures.Entries","product":"core","slug":"tmux-terminalfeatures-entries"},{"id":"tmux.TerminalFeatures.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.TerminalFeatures","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of distinct terminal patterns."},"source":{"file":"tmux/complex_options.go","line":109,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalFeatures.Len","product":"core","slug":"tmux-terminalfeatures-len"},{"id":"tmux.TerminalOverrideValueKind","name":"TerminalOverrideValueKind","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverrideValueKind identifies one closed terminal capability value form."},"source":{"file":"tmux/complex_options.go","line":112,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValueKind","product":"core","slug":"tmux-terminaloverridevaluekind"},{"id":"tmux.TerminalOverrideValueFlag","name":"TerminalOverrideValueFlag","kind":"constant","modifiers":[],"signatures":[],"type":"TerminalOverrideValueKind","doc":{"summary":"TerminalOverrideValueFlag identifies a capability without an assigned value."},"source":{"file":"tmux/complex_options.go","line":116,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValueFlag","product":"core","slug":"tmux-terminaloverridevalueflag"},{"id":"tmux.TerminalOverrideValueInteger","name":"TerminalOverrideValueInteger","kind":"constant","modifiers":[],"signatures":[],"type":"TerminalOverrideValueKind","doc":{"summary":"TerminalOverrideValueInteger identifies an unsigned decimal integer."},"source":{"file":"tmux/complex_options.go","line":118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValueInteger","product":"core","slug":"tmux-terminaloverridevalueinteger"},{"id":"tmux.TerminalOverrideValueText","name":"TerminalOverrideValueText","kind":"constant","modifiers":[],"signatures":[],"type":"TerminalOverrideValueKind","doc":{"summary":"TerminalOverrideValueText identifies an assigned non-integer string."},"source":{"file":"tmux/complex_options.go","line":120,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValueText","product":"core","slug":"tmux-terminaloverridevaluetext"},{"id":"tmux.TerminalOverrideValue","name":"TerminalOverrideValue","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverrideValue is a flag, arbitrary-precision integer, or string. Its zero value has no recognized kind: IsFlag is false, Integer and Text report false, and it represents no parsed capability assignment."},"source":{"file":"tmux/complex_options.go","line":126,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValue","product":"core","slug":"tmux-terminaloverridevalue"},{"id":"tmux.TerminalOverrideValue.Kind","name":"Kind","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrideValue","signatures":[{"params":[],"returns":"TerminalOverrideValueKind"}],"doc":{"summary":"Kind returns the value's closed form."},"source":{"file":"tmux/complex_options.go","line":132,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValue.Kind","product":"core","slug":"tmux-terminaloverridevalue-kind"},{"id":"tmux.TerminalOverrideValue.IsFlag","name":"IsFlag","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrideValue","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"IsFlag reports whether the capability has no assigned value."},"source":{"file":"tmux/complex_options.go","line":135,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValue.IsFlag","product":"core","slug":"tmux-terminaloverridevalue-isflag"},{"id":"tmux.TerminalOverrideValue.Integer","name":"Integer","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrideValue","signatures":[{"params":[],"returns":"(*big.Int, bool)"}],"doc":{"summary":"Integer returns a fresh arbitrary-precision integer when the value is numeric."},"source":{"file":"tmux/complex_options.go","line":140,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValue.Integer","product":"core","slug":"tmux-terminaloverridevalue-integer"},{"id":"tmux.TerminalOverrideValue.Text","name":"Text","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrideValue","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Text returns the assigned string when the value is textual."},"source":{"file":"tmux/complex_options.go","line":149,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideValue.Text","product":"core","slug":"tmux-terminaloverridevalue-text"},{"id":"tmux.TerminalCapability","name":"TerminalCapability","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalCapability is one parsed terminal override capability."},"source":{"file":"tmux/complex_options.go","line":157,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalCapability","product":"core","slug":"tmux-terminalcapability"},{"id":"tmux.TerminalCapability.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.TerminalCapability","signatures":[],"type":"string","doc":{"summary":"Name is the capability name."},"source":{"file":"tmux/complex_options.go","line":159,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalCapability.Name","product":"core","slug":"tmux-terminalcapability-name"},{"id":"tmux.TerminalCapability.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.TerminalCapability","signatures":[],"type":"TerminalOverrideValue","doc":{"summary":"Value is the parsed capability value."},"source":{"file":"tmux/complex_options.go","line":161,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalCapability.Value","product":"core","slug":"tmux-terminalcapability-value"},{"id":"tmux.TerminalOverride","name":"TerminalOverride","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverride is the immutable capability set for one terminal pattern. Its zero value is an empty immutable collection: Len is zero, Lookup reports false, and Entries returns a nonnil empty slice."},"source":{"file":"tmux/complex_options.go","line":167,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverride","product":"core","slug":"tmux-terminaloverride"},{"id":"tmux.TerminalOverride.Lookup","name":"Lookup","kind":"method","modifiers":[],"parent":"tmux.TerminalOverride","signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(TerminalOverrideValue, bool)"}],"doc":{"summary":"Lookup returns one capability value."},"source":{"file":"tmux/complex_options.go","line":173,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverride.Lookup","product":"core","slug":"tmux-terminaloverride-lookup"},{"id":"tmux.TerminalOverride.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.TerminalOverride","signatures":[{"params":[],"returns":"[]TerminalCapability"}],"doc":{"summary":"Entries returns a fresh slice in first-definition order."},"source":{"file":"tmux/complex_options.go","line":182,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverride.Entries","product":"core","slug":"tmux-terminaloverride-entries"},{"id":"tmux.TerminalOverride.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.TerminalOverride","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of distinct capabilities."},"source":{"file":"tmux/complex_options.go","line":187,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverride.Len","product":"core","slug":"tmux-terminaloverride-len"},{"id":"tmux.TerminalOverrideEntry","name":"TerminalOverrideEntry","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverrideEntry is one terminal pattern and its parsed capabilities."},"source":{"file":"tmux/complex_options.go","line":190,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideEntry","product":"core","slug":"tmux-terminaloverrideentry"},{"id":"tmux.TerminalOverrideEntry.Terminal","name":"Terminal","kind":"attribute","modifiers":[],"parent":"tmux.TerminalOverrideEntry","signatures":[],"type":"string","doc":{"summary":"Terminal is the terminal pattern."},"source":{"file":"tmux/complex_options.go","line":192,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideEntry.Terminal","product":"core","slug":"tmux-terminaloverrideentry-terminal"},{"id":"tmux.TerminalOverrideEntry.Capabilities","name":"Capabilities","kind":"attribute","modifiers":[],"parent":"tmux.TerminalOverrideEntry","signatures":[],"type":"TerminalOverride","doc":{"summary":"Capabilities is the immutable capability set for Terminal."},"source":{"file":"tmux/complex_options.go","line":194,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrideEntry.Capabilities","product":"core","slug":"tmux-terminaloverrideentry-capabilities"},{"id":"tmux.TerminalOverrides","name":"TerminalOverrides","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TerminalOverrides is an immutable parsed terminal-overrides option. Its zero value is an empty immutable collection: Len is zero, Lookup reports false, and Entries returns a nonnil empty slice."},"source":{"file":"tmux/complex_options.go","line":200,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrides","product":"core","slug":"tmux-terminaloverrides"},{"id":"tmux.TerminalOverrides.Lookup","name":"Lookup","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrides","signatures":[{"params":[{"name":"terminal","type":"string"}],"returns":"(TerminalOverride, bool)"}],"doc":{"summary":"Lookup returns the capabilities for terminal."},"source":{"file":"tmux/complex_options.go","line":206,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrides.Lookup","product":"core","slug":"tmux-terminaloverrides-lookup"},{"id":"tmux.TerminalOverrides.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrides","signatures":[{"params":[],"returns":"[]TerminalOverrideEntry"}],"doc":{"summary":"Entries returns a fresh outer slice in first-definition order. Nested TerminalOverride values remain immutable."},"source":{"file":"tmux/complex_options.go","line":216,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrides.Entries","product":"core","slug":"tmux-terminaloverrides-entries"},{"id":"tmux.TerminalOverrides.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.TerminalOverrides","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of distinct terminal patterns."},"source":{"file":"tmux/complex_options.go","line":221,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TerminalOverrides.Len","product":"core","slug":"tmux-terminaloverrides-len"},{"id":"tmux.ServerOptionValues.CommandAliases","name":"CommandAliases","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"(OptionValue[CommandAliases], error)"}],"doc":{"summary":"CommandAliases parses command-alias while preserving option presence and origin. A nonnil joined error contains [ComplexOptionDecodeError] values, each usable with [errors.Is] or [errors.As]; the returned projection still contains every valid entry and is owned by the caller."},"source":{"file":"tmux/complex_options.go","line":227,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.CommandAliases","product":"core","slug":"tmux-serveroptionvalues-commandaliases"},{"id":"tmux.ServerOptionValues.ParsedTerminalFeatures","name":"ParsedTerminalFeatures","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"(OptionValue[TerminalFeatures], error)"}],"doc":{"summary":"ParsedTerminalFeatures parses terminal-features while preserving option presence and origin. A nonnil joined error contains [ComplexOptionDecodeError] values and the returned owned projection contains every valid entry."},"source":{"file":"tmux/complex_options.go","line":253,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.ParsedTerminalFeatures","product":"core","slug":"tmux-serveroptionvalues-parsedterminalfeatures"},{"id":"tmux.ServerOptionValues.ParsedTerminalOverrides","name":"ParsedTerminalOverrides","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"(OptionValue[TerminalOverrides], error)"}],"doc":{"summary":"ParsedTerminalOverrides parses terminal-overrides while preserving option presence and origin. Terminal-overrides syntax is permissive: no malformed entry error is returned, and the result owns its parsed projection."},"source":{"file":"tmux/complex_options.go","line":278,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.ParsedTerminalOverrides","product":"core","slug":"tmux-serveroptionvalues-parsedterminaloverrides"},{"id":"tmux.ErrConnectionRequiresProcess","name":"ErrConnectionRequiresProcess","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrConnectionRequiresProcess identifies an operation refused because a terminal [Connection] cannot start a tmux process outside its owned lanes."},"source":{"file":"tmux/connection.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrConnectionRequiresProcess","product":"core","slug":"tmux-errconnectionrequiresprocess"},{"id":"tmux.ConnectionOptions","name":"ConnectionOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ConnectionOptions configures the control-mode lanes owned by a [Connection]."},"source":{"file":"tmux/connection.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ConnectionOptions","product":"core","slug":"tmux-connectionoptions"},{"id":"tmux.ConnectionOptions.Lanes","name":"Lanes","kind":"attribute","modifiers":[],"parent":"tmux.ConnectionOptions","signatures":[],"type":"int","doc":{"summary":"Lanes is the number of concurrent command lanes. Zero opens one. Each lane is an attached tmux client and carries one command at a time."},"source":{"file":"tmux/connection.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ConnectionOptions.Lanes","product":"core","slug":"tmux-connectionoptions-lanes"},{"id":"tmux.Connection","name":"Connection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Connection owns terminal control-mode transport to the exact daemon that materialized its session. Values obtained from Server or Session retain the connection. Closing is terminal: they neither reconnect nor fall back to a subprocess. Its lanes are attached tmux clients; closing the last client can trigger tmux's destroy-unattached or exit-unattached policy. On tmux 3.6 or later, destroying its initial session moves the clients to another session when one exists; the retained Session value keeps its original identity.","body":"It is what a record runs through. [Server.OpenControl] returns a\n[ControlClient] instead, one client carrying commands and notifications\nwith no record bound to it."},"source":{"file":"tmux/connection.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Connection","product":"core","slug":"tmux-connection"},{"id":"tmux.Server.ConnectionBound","name":"ConnectionBound","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"ConnectionBound reports whether this handle retains terminal transport owned by a [Connection]. A bound handle never reconnects or falls back to a tmux subprocess after that connection closes."},"source":{"file":"tmux/connection.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ConnectionBound","product":"core","slug":"tmux-server-connectionbound"},{"id":"tmux.Session.OpenControl","name":"OpenControl","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"options","type":"ConnectionOptions"}],"returns":"(*Connection, error)"}],"doc":{"summary":"OpenControl opens terminal control-mode transport to the receiver's daemon. The returned connection owns its lanes and must be closed. A receiver already bound to a connection cannot be rebound. Before tmux 3.6, destroying the attached session follows that session's detach-on-destroy policy and may end the connection."},"source":{"file":"tmux/connection.go","line":87,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.OpenControl","product":"core","slug":"tmux-session-opencontrol"},{"id":"tmux.Server.NewSessionConnection","name":"NewSessionConnection","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewSessionRequest"},{"name":"options","type":"ConnectionOptions"}],"returns":"(Session, *Connection, error)"}],"doc":{"summary":"NewSessionConnection creates a session with a control-mode client and keeps that same process as the first terminal command lane. Unlike [Server.NewSession], it creates an attached session. If tmux reports a valid session ID before later setup fails, the returned partial session retains that ID and server. Cleanup closes the attached creator, so tmux policy may make the partial session no longer live. Before tmux 3.6, destroying the created session follows its detach-on-destroy policy and may end the connection. KillExisting is rejected because removing an existing session cannot be rolled back if later connection setup fails."},"source":{"file":"tmux/connection.go","line":124,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.NewSessionConnection","product":"core","slug":"tmux-server-newsessionconnection"},{"id":"tmux.Connection.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the ordinary server value bound to this connection."},"source":{"file":"tmux/connection.go","line":318,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Connection.Server","product":"core","slug":"tmux-connection-server"},{"id":"tmux.Connection.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[],"returns":"Session"}],"doc":{"summary":"Session returns the attached session value bound to this connection."},"source":{"file":"tmux/connection.go","line":321,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Connection.Session","product":"core","slug":"tmux-connection-session"},{"id":"tmux.Connection.Lanes","name":"Lanes","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Lanes reports the number of owned control-mode command lanes."},"source":{"file":"tmux/connection.go","line":324,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Connection.Lanes","product":"core","slug":"tmux-connection-lanes"},{"id":"tmux.Connection.Call","name":"Call","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"([]ControlCommandResult, error)"}],"doc":{"summary":"Call executes one safely encoded tmux command on an owned lane and returns every reply frame in order. An alias may produce zero or multiple frames; a %error frame remains result data through [ControlCommandResult.Failed]. Args always describe one command, so a bare semicolon is quoted as an operand rather than interpreted as a command-list separator."},"source":{"file":"tmux/connection.go","line":336,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Connection.Call","product":"core","slug":"tmux-connection-call"},{"id":"tmux.Connection.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts terminal shutdown and waits within ctx. The context bounds only the wait; a later call may resume waiting for the same shutdown."},"source":{"file":"tmux/connection.go","line":359,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Connection.CloseContext","product":"core","slug":"tmux-connection-closecontext"},{"id":"tmux.Connection.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmux.Connection","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close terminally closes every lane on bounded internal contexts. It is safe to call concurrently and more than once."},"source":{"file":"tmux/connection.go","line":368,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Connection.Close","product":"core","slug":"tmux-connection-close"},{"id":"tmux.ErrControlClosed","name":"ErrControlClosed","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlClosed identifies an operation attempted after a control client began closing or lost its protocol stream."},"source":{"file":"tmux/control_client.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrControlClosed","product":"core","slug":"tmux-errcontrolclosed"},{"id":"tmux.ErrControlStreamLost","name":"ErrControlStreamLost","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlStreamLost identifies a [ControlClient.NextNotification] stream that ended before the caller asked to close it, distinct from the clean end an explicit Close or CloseContext produces. It is most often the underlying tmux client process exiting because the server it was attached to did."},"source":{"file":"tmux/control_client.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrControlStreamLost","product":"core","slug":"tmux-errcontrolstreamlost"},{"id":"tmux.ErrOutcomeUnknown","name":"ErrOutcomeUnknown","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrOutcomeUnknown identifies a command whose write began but whose reply boundary was not observed. The operation may have changed tmux."},"source":{"file":"tmux/control_client.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrOutcomeUnknown","product":"core","slug":"tmux-erroutcomeunknown"},{"id":"tmux.ErrControlReplyCount","name":"ErrControlReplyCount","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlReplyCount identifies a call to [ControlClient.Cmd] for a command that produced zero or multiple reply frames."},"source":{"file":"tmux/control_client.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrControlReplyCount","product":"core","slug":"tmux-errcontrolreplycount"},{"id":"tmux.ControlClient","name":"ControlClient","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlClient is one attached tmux control-mode process. Create one with [Server.OpenControl]. Concurrent Cmd, Wait, and close calls are supported; exactly one caller may execute NextNotification at a time.","body":"It is the low-level handle: it carries commands and notifications on one\nclient and can [ControlClient.Reconnect], but records do not run through it.\n[Session.OpenControl] returns a [Connection] instead, whose lanes the\nsessions, windows and panes obtained from it use for their own commands."},"source":{"file":"tmux/control_client.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient","product":"core","slug":"tmux-controlclient"},{"id":"tmux.ControlClient.ClientName","name":"ClientName","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[],"returns":"ClientName"}],"doc":{"summary":"ClientName returns the tmux-assigned identity captured during registration."},"source":{"file":"tmux/control_client.go","line":101,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.ClientName","product":"core","slug":"tmux-controlclient-clientname"},{"id":"tmux.ControlClient.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the server handle used to start the control client."},"source":{"file":"tmux/control_client.go","line":104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.Server","product":"core","slug":"tmux-controlclient-server"},{"id":"tmux.ControlClient.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[],"returns":"Session"}],"doc":{"summary":"Session returns the materialized session selected during startup."},"source":{"file":"tmux/control_client.go","line":107,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.Session","product":"core","slug":"tmux-controlclient-session"},{"id":"tmux.ControlClient.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Wait blocks until the control process exits or ctx ends. It does not close the notification queue; callers may drain final notifications before Close."},"source":{"file":"tmux/control_lifecycle.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.Wait","product":"core","slug":"tmux-controlclient-wait"},{"id":"tmux.ControlClient.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts idempotent control-client shutdown and waits within ctx. The context bounds only the wait: an already-ended context still starts shutdown, and a later call may resume waiting for the same close."},"source":{"file":"tmux/control_lifecycle.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.CloseContext","product":"core","slug":"tmux-controlclient-closecontext"},{"id":"tmux.ControlClient.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the control process and releases its notification queue. It is safe to call concurrently and more than once."},"source":{"file":"tmux/control_lifecycle.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.Close","product":"core","slug":"tmux-controlclient-close"},{"id":"tmux.ControlClient.Reconnect","name":"Reconnect","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(*ControlClient, error)"}],"doc":{"summary":"Reconnect registers a replacement on the last attached session observed at a reply boundary, then closes the receiver. Failed replacement setup does not initiate receiver shutdown. If shutdown fails, Reconnect returns the live replacement with that error; the caller owns every non-nil result. A receiver whose stream ended cleanly can recover from its last observation. Commands are never replayed."},"source":{"file":"tmux/control_lifecycle.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.Reconnect","product":"core","slug":"tmux-controlclient-reconnect"},{"id":"tmux.ErrMalformedControlNotification","name":"ErrMalformedControlNotification","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedControlNotification identifies a structurally invalid control-mode notification."},"source":{"file":"tmux/control_notification.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrMalformedControlNotification","product":"core","slug":"tmux-errmalformedcontrolnotification"},{"id":"tmux.ErrUnknownControlNotification","name":"ErrUnknownControlNotification","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrUnknownControlNotification identifies a well-framed notification kind outside the pinned control-mode vocabulary."},"source":{"file":"tmux/control_notification.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrUnknownControlNotification","product":"core","slug":"tmux-errunknowncontrolnotification"},{"id":"tmux.ControlNotificationError","name":"ControlNotificationError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlNotificationError reports where a control-mode notification failed validation without retaining or disclosing the notification contents. Callers can use [errors.Is] with Category or [errors.As] to inspect its secret-safe location metadata. Category is [ErrMalformedControlNotification] or [ErrUnknownControlNotification]."},"source":{"file":"tmux/control_notification.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationError","product":"core","slug":"tmux-controlnotificationerror"},{"id":"tmux.ControlNotificationError.Offset","name":"Offset","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[],"type":"int","doc":{"summary":"Offset is the byte offset of the malformed protocol element."},"source":{"file":"tmux/control_notification.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationError.Offset","product":"core","slug":"tmux-controlnotificationerror-offset"},{"id":"tmux.ControlNotificationError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[],"type":"string","doc":{"summary":"Reason describes the framing or vocabulary error without retaining input."},"source":{"file":"tmux/control_notification.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationError.Reason","product":"core","slug":"tmux-controlnotificationerror-reason"},{"id":"tmux.ControlNotificationError.Category","name":"Category","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[],"type":"error","doc":{"summary":"Category is ErrMalformedControlNotification or ErrUnknownControlNotification."},"source":{"file":"tmux/control_notification.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationError.Category","product":"core","slug":"tmux-controlnotificationerror-category"},{"id":"tmux.ControlNotificationError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/control_notification.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationError.Error","product":"core","slug":"tmux-controlnotificationerror-error"},{"id":"tmux.ControlNotificationError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ControlNotificationError compatible with its Category."},"source":{"file":"tmux/control_notification.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationError.Unwrap","product":"core","slug":"tmux-controlnotificationerror-unwrap"},{"id":"tmux.ControlNotification","name":"ControlNotification","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlNotification is an immutable parsed tmux control-mode notification. Its zero value has an empty kind and no arguments. Values returned by [ParseControlNotification] own copied arguments and are safe to retain."},"source":{"file":"tmux/control_notification.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotification","product":"core","slug":"tmux-controlnotification"},{"id":"tmux.ControlNotification.Kind","name":"Kind","kind":"method","modifiers":[],"parent":"tmux.ControlNotification","signatures":[{"params":[],"returns":"ControlNotificationKind"}],"doc":{"summary":"Kind returns the notification's protocol kind."},"source":{"file":"tmux/control_notification.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotification.Kind","product":"core","slug":"tmux-controlnotification-kind"},{"id":"tmux.ControlNotification.Arguments","name":"Arguments","kind":"method","modifiers":[],"parent":"tmux.ControlNotification","signatures":[{"params":[],"returns":"[]string"}],"doc":{"summary":"Arguments returns an owned copy of the notification arguments. Arguments before a documented free-form tail are individual values; the tail is the final value and preserves its spacing and tmux escaping."},"source":{"file":"tmux/control_notification.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotification.Arguments","product":"core","slug":"tmux-controlnotification-arguments"},{"id":"tmux.ControlNotification.Output","name":"Output","kind":"method","modifiers":[],"parent":"tmux.ControlNotification","signatures":[{"params":[],"returns":"(PaneID, []byte, bool)"}],"doc":{"summary":"Output returns the pane identity and decoded caller-owned bytes carried by an output or extended-output notification. Other notification kinds return zero values and false."},"source":{"file":"tmux/control_notification.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotification.Output","product":"core","slug":"tmux-controlnotification-output"},{"id":"tmux.SubscriptionChange","name":"SubscriptionChange","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SubscriptionChange is one evaluated format value reported by a subscription armed with [NotificationStream.Subscribe]. The scope fields tmux did not evaluate against are zero: a session-scoped subscription reports no window or pane, and a window-scoped one reports no pane."},"source":{"file":"tmux/control_notification.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionChange","product":"core","slug":"tmux-subscriptionchange"},{"id":"tmux.SubscriptionChange.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"string","doc":{"summary":"Name is the subscription name given when it was armed."},"source":{"file":"tmux/control_notification.go","line":78,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionChange.Name","product":"core","slug":"tmux-subscriptionchange-name"},{"id":"tmux.SubscriptionChange.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"SessionID","doc":{"summary":"Session is the session the value was evaluated for."},"source":{"file":"tmux/control_notification.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionChange.Session","product":"core","slug":"tmux-subscriptionchange-session"},{"id":"tmux.SubscriptionChange.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"WindowID","doc":{"summary":"Window is the window the value was evaluated for, when scoped to one."},"source":{"file":"tmux/control_notification.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionChange.Window","product":"core","slug":"tmux-subscriptionchange-window"},{"id":"tmux.SubscriptionChange.WindowIndex","name":"WindowIndex","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"int","doc":{"summary":"WindowIndex is Window's index in Session. It means nothing when Window is zero."},"source":{"file":"tmux/control_notification.go","line":85,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionChange.WindowIndex","product":"core","slug":"tmux-subscriptionchange-windowindex"},{"id":"tmux.SubscriptionChange.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"PaneID","doc":{"summary":"Pane is the pane the value was evaluated for, when scoped to one."},"source":{"file":"tmux/control_notification.go","line":87,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionChange.Pane","product":"core","slug":"tmux-subscriptionchange-pane"},{"id":"tmux.SubscriptionChange.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionChange","signatures":[],"type":"string","doc":{"summary":"Value is the format expanded by tmux."},"source":{"file":"tmux/control_notification.go","line":89,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionChange.Value","product":"core","slug":"tmux-subscriptionchange-value"},{"id":"tmux.ControlNotification.Subscription","name":"Subscription","kind":"method","modifiers":[],"parent":"tmux.ControlNotification","signatures":[{"params":[],"returns":"(SubscriptionChange, bool)"}],"doc":{"summary":"Subscription returns the change carried by a subscription-changed notification. Other notification kinds return a zero value and false."},"source":{"file":"tmux/control_notification.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotification.Subscription","product":"core","slug":"tmux-controlnotification-subscription"},{"id":"tmux.ParseControlNotification","name":"ParseControlNotification","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"line","type":"[]byte"}],"returns":"(ControlNotification, error)"}],"doc":{"summary":"ParseControlNotification parses one newline-free tmux control-mode notification record. It requires exact control framing and a supported kind, returns errors compatible with [ErrMalformedControlNotification] or [ErrUnknownControlNotification], and copies all caller-owned input before returning. It never returns a partial notification."},"source":{"file":"tmux/control_notification.go","line":125,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ParseControlNotification","product":"core","slug":"tmux-parsecontrolnotification"},{"id":"tmux.ErrControlNotificationOverflow","name":"ErrControlNotificationOverflow","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlNotificationOverflow identifies a watcher that did not consume notifications before its bounded backlog filled."},"source":{"file":"tmux/control_notification_queue.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrControlNotificationOverflow","product":"core","slug":"tmux-errcontrolnotificationoverflow"},{"id":"tmux.ControlNotificationOverflowError","name":"ControlNotificationOverflowError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlNotificationOverflowError reports the backlog limit and the record that would have crossed it. The queued prefix remains available first."},"source":{"file":"tmux/control_notification_queue.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationOverflowError","product":"core","slug":"tmux-controlnotificationoverflowerror"},{"id":"tmux.ControlNotificationOverflowError.LimitBytes","name":"LimitBytes","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[],"type":"int","doc":{"summary":"LimitBytes is the maximum retained payload and queue framing."},"source":{"file":"tmux/control_notification_queue.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationOverflowError.LimitBytes","product":"core","slug":"tmux-controlnotificationoverflowerror-limitbytes"},{"id":"tmux.ControlNotificationOverflowError.PendingBytes","name":"PendingBytes","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[],"type":"int","doc":{"summary":"PendingBytes is the unread payload and queue framing retained at overflow."},"source":{"file":"tmux/control_notification_queue.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationOverflowError.PendingBytes","product":"core","slug":"tmux-controlnotificationoverflowerror-pendingbytes"},{"id":"tmux.ControlNotificationOverflowError.NotificationBytes","name":"NotificationBytes","kind":"attribute","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[],"type":"int","doc":{"summary":"NotificationBytes is the size of the first notification not retained."},"source":{"file":"tmux/control_notification_queue.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationOverflowError.NotificationBytes","product":"core","slug":"tmux-controlnotificationoverflowerror-notificationbytes"},{"id":"tmux.ControlNotificationOverflowError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error describes the bounded backlog without disclosing notification data."},"source":{"file":"tmux/control_notification_queue.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationOverflowError.Error","product":"core","slug":"tmux-controlnotificationoverflowerror-error"},{"id":"tmux.ControlNotificationOverflowError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationOverflowError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ControlNotificationOverflowError compatible with ErrControlNotificationOverflow."},"source":{"file":"tmux/control_notification_queue.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationOverflowError.Unwrap","product":"core","slug":"tmux-controlnotificationoverflowerror-unwrap"},{"id":"tmux.ErrPaneObservationLost","name":"ErrPaneObservationLost","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrPaneObservationLost identifies a pane observation whose control client can no longer receive every byte after its baseline. Stream failures that wrap it also preserve their underlying cause."},"source":{"file":"tmux/control_observation.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrPaneObservationLost","product":"core","slug":"tmux-errpaneobservationlost"},{"id":"tmux.PaneObservation","name":"PaneObservation","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneObservation is one visible pane baseline followed by the exact control notification stream after that baseline. That stream is the observation's whole control connection, so a caller wanting only this pane's output selects it by identifier. Create one with [Pane.OpenObservation] and close it when finished. Copies share notification reader ownership, terminal loss, and client lifetime; closing one closes them all."},"source":{"file":"tmux/control_observation.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation","product":"core","slug":"tmux-paneobservation"},{"id":"tmux.PaneObservation.PaneID","name":"PaneID","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"PaneID"}],"doc":{"summary":"PaneID returns the pane selected at the observation boundary."},"source":{"file":"tmux/control_observation.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.PaneID","product":"core","slug":"tmux-paneobservation-paneid"},{"id":"tmux.PaneObservation.SessionID","name":"SessionID","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"SessionID"}],"doc":{"summary":"SessionID returns the session the observation's own control client attached to, resolved live when the observation opened - the session a listing must count this client's attachment against, not merely the pane's session at some other, possibly stale, snapshot."},"source":{"file":"tmux/control_observation.go","line":66,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.SessionID","product":"core","slug":"tmux-paneobservation-sessionid"},{"id":"tmux.PaneObservation.ClientName","name":"ClientName","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"ClientName"}],"doc":{"summary":"ClientName returns the observation's own control client identity - the name a listing of attached clients must exclude, the same way it already excludes a caller's long-lived command connection, so a caller's own stream never reads as another person watching."},"source":{"file":"tmux/control_observation.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.ClientName","product":"core","slug":"tmux-paneobservation-clientname"},{"id":"tmux.PaneObservation.Baseline","name":"Baseline","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"[]string"}],"doc":{"summary":"Baseline returns an owned copy of the pane's visible text at the observation boundary."},"source":{"file":"tmux/control_observation.go","line":86,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.Baseline","product":"core","slug":"tmux-paneobservation-baseline"},{"id":"tmux.PaneObservation.NextNotification","name":"NextNotification","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ControlNotification, error)"}],"doc":{"summary":"NextNotification returns the next notification strictly after the pane baseline, from the whole connection rather than this pane alone. Notifications queued before that boundary are discarded. Concurrent calls are serialized. Caller context errors and [ControlNotificationError] affect only one call. Explicit close returns an error matching [os.ErrClosed].","body":"Topology loss, natural stream EOF, and terminal reader errors return\n[ErrPaneObservationLost]. Stream failures preserve their cause. Later calls\nreturn that loss without consuming more notifications."},"source":{"file":"tmux/control_observation.go","line":103,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.NextNotification","product":"core","slug":"tmux-paneobservation-nextnotification"},{"id":"tmux.PaneObservation.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the dedicated control client. It is safe to call more than once."},"source":{"file":"tmux/control_observation.go","line":271,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.Close","product":"core","slug":"tmux-paneobservation-close"},{"id":"tmux.PaneObservation.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts idempotent observation shutdown and waits within ctx."},"source":{"file":"tmux/control_observation.go","line":279,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.CloseContext","product":"core","slug":"tmux-paneobservation-closecontext"},{"id":"tmux.Pane.OpenObservation","name":"OpenObservation","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(*PaneObservation, error)"}],"doc":{"summary":"OpenObservation captures the pane's visible text and returns an owned observation whose notifications begin at the capture's exact control-wire boundary. It resolves the pane's exact linked session before opening a dedicated control client. The caller must close the result."},"source":{"file":"tmux/control_observation.go","line":290,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.OpenObservation","product":"core","slug":"tmux-pane-openobservation"},{"id":"tmux.PaneObservation.Reader","name":"Reader","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"io.Reader"}],"doc":{"summary":"Reader returns the pane's output after the baseline as a byte stream: what the program in the pane writes to its terminal, in order, and nothing from any other pane on the connection. Reads block until the pane writes, ctx ends, or the observation closes. A lost observation ends the stream with [ErrPaneObservationLost] rather than [io.EOF]. The bytes are the terminal's: escape sequences and carriage returns arrive as written, and the echo of what is typed into the pane arrives before the reply, as it does on screen. Exactly one reader or direct notification read may run at a time.","body":"A malformed notification on the connection is skipped, as\n[PaneObservation.Notifications] skips it; every other error ends the stream."},"source":{"file":"tmux/control_observation.go","line":453,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.Reader","product":"core","slug":"tmux-paneobservation-reader"},{"id":"tmux.PaneObservation.Notifications","name":"Notifications","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"iter.Seq2[ControlNotification, error]"}],"doc":{"summary":"Notifications returns [PaneObservation.NextNotification] as a range loop; exactly one iterator or direct read may run at a time. Malformed notifications yield their error and iteration continues; every other error ends the loop after being yielded."},"source":{"file":"tmux/control_observation.go","line":490,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.Notifications","product":"core","slug":"tmux-paneobservation-notifications"},{"id":"tmux.ErrControlProtocol","name":"ErrControlProtocol","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrControlProtocol identifies malformed tmux control-mode framing."},"source":{"file":"tmux/control_protocol.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrControlProtocol","product":"core","slug":"tmux-errcontrolprotocol"},{"id":"tmux.ControlProtocolError","name":"ControlProtocolError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlProtocolError reports a control-stream state violation without retaining or disclosing command output or notification contents. It matches [ErrControlProtocol] through errors.Is."},"source":{"file":"tmux/control_protocol.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlProtocolError","product":"core","slug":"tmux-controlprotocolerror"},{"id":"tmux.ControlProtocolError.State","name":"State","kind":"attribute","modifiers":[],"parent":"tmux.ControlProtocolError","signatures":[],"type":"string","doc":{"summary":"State is the parser state in which the violation occurred."},"source":{"file":"tmux/control_protocol.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlProtocolError.State","product":"core","slug":"tmux-controlprotocolerror-state"},{"id":"tmux.ControlProtocolError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.ControlProtocolError","signatures":[],"type":"string","doc":{"summary":"Reason describes the structural violation without quoting input."},"source":{"file":"tmux/control_protocol.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlProtocolError.Reason","product":"core","slug":"tmux-controlprotocolerror-reason"},{"id":"tmux.ControlProtocolError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ControlProtocolError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/control_protocol.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlProtocolError.Error","product":"core","slug":"tmux-controlprotocolerror-error"},{"id":"tmux.ControlProtocolError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ControlProtocolError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ControlProtocolError compatible with ErrControlProtocol."},"source":{"file":"tmux/control_protocol.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlProtocolError.Unwrap","product":"core","slug":"tmux-controlprotocolerror-unwrap"},{"id":"tmux.ControlCommandResult","name":"ControlCommandResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlCommandResult is one completed control-mode command frame. A failed tmux command remains result data through Failed; local, protocol, transport, and context failures are returned separately by [Connection.Call], [ControlClient.Cmd], and [ControlClient.Call]. All slices are owned by the caller."},"source":{"file":"tmux/control_protocol.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlCommandResult","product":"core","slug":"tmux-controlcommandresult"},{"id":"tmux.ControlCommandResult.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"[]string","doc":{"summary":"Command is the safely encoded command's original argument vector."},"source":{"file":"tmux/control_protocol.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlCommandResult.Command","product":"core","slug":"tmux-controlcommandresult-command"},{"id":"tmux.ControlCommandResult.RawStdout","name":"RawStdout","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"[]byte","doc":{"summary":"RawStdout contains exact frame payload bytes, including each line's LF."},"source":{"file":"tmux/control_protocol.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlCommandResult.RawStdout","product":"core","slug":"tmux-controlcommandresult-rawstdout"},{"id":"tmux.ControlCommandResult.Timestamp","name":"Timestamp","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"int64","doc":{"summary":"Timestamp is tmux's frame timestamp in Unix seconds."},"source":{"file":"tmux/control_protocol.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlCommandResult.Timestamp","product":"core","slug":"tmux-controlcommandresult-timestamp"},{"id":"tmux.ControlCommandResult.Number","name":"Number","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"uint64","doc":{"summary":"Number is tmux's command number for the frame. tmux counts commands the server processed rather than commands this client sent, so a command from any other client advances it too and the gap between two frames is not a count of this client's work."},"source":{"file":"tmux/control_protocol.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlCommandResult.Number","product":"core","slug":"tmux-controlcommandresult-number"},{"id":"tmux.ControlCommandResult.Flags","name":"Flags","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"int","doc":{"summary":"Flags contains tmux's frame flags."},"source":{"file":"tmux/control_protocol.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlCommandResult.Flags","product":"core","slug":"tmux-controlcommandresult-flags"},{"id":"tmux.ControlCommandResult.Failed","name":"Failed","kind":"attribute","modifiers":[],"parent":"tmux.ControlCommandResult","signatures":[],"type":"bool","doc":{"summary":"Failed reports whether tmux closed the frame with %error instead of %end."},"source":{"file":"tmux/control_protocol.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlCommandResult.Failed","product":"core","slug":"tmux-controlcommandresult-failed"},{"id":"tmux.ControlClient.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(ControlCommandResult, error)"}],"doc":{"summary":"Cmd executes one safely encoded tmux command through the control client. It requires exactly one reply frame and returns [ErrControlReplyCount] otherwise. Use [ControlClient.Call] for aliases that may produce zero or multiple frames."},"source":{"file":"tmux/control_request.go","line":95,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.Cmd","product":"core","slug":"tmux-controlclient-cmd"},{"id":"tmux.ControlClient.Call","name":"Call","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"([]ControlCommandResult, error)"}],"doc":{"summary":"Call executes one safely encoded tmux command and returns all its reply frames. Cancellation after writing returns [ErrOutcomeUnknown] with the context error while the client drains through the boundary before reuse. A transport failure returns any frames proven before the failure together with [ErrOutcomeUnknown]."},"source":{"file":"tmux/control_request.go","line":118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.Call","product":"core","slug":"tmux-controlclient-call"},{"id":"tmux.Server.OpenControl","name":"OpenControl","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"session","type":"Session"}],"returns":"(*ControlClient, error)"}],"doc":{"summary":"OpenControl starts a control-mode client attached to session. The startup context bounds process start, attach framing, and client registration but does not own the returned client's lifetime. Session must belong to the same configured server selector."},"source":{"file":"tmux/control_startup.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.OpenControl","product":"core","slug":"tmux-server-opencontrol"},{"id":"tmux.ControlClient.NextNotification","name":"NextNotification","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ControlNotification, error)"}],"doc":{"summary":"NextNotification returns the next ordered control-mode notification. Exactly one caller may execute it at a time. Close releases the queue and makes subsequent reads report os.ErrClosed, drained through queued notifications first. Natural process exit before a caller asked to close instead reports [ErrControlStreamLost] - most often because the server the underlying tmux client was attached to exited - naming the tmux exit reason when one was sent. A terminal reader error follows notifications queued before that failure. A full bounded queue likewise drains before reporting [ControlNotificationOverflowError]."},"source":{"file":"tmux/control_stream.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.NextNotification","product":"core","slug":"tmux-controlclient-nextnotification"},{"id":"tmux.ControlClient.Notifications","name":"Notifications","kind":"method","modifiers":[],"parent":"tmux.ControlClient","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"iter.Seq2[ControlNotification, error]"}],"doc":{"summary":"Notifications returns an iterator over what tmux says without being asked: pane output, and the events behind [ControlNotification].","body":"It is [ControlClient.NextNotification] as a range loop; exactly one iterator\nor direct notification read may run at a time.\n\nfor notification, err := range client.Notifications(ctx) {\n\tif err != nil {\n\t\treturn err\n\t}\n\tif pane, output, ok := notification.Output(); ok {\n\t\thandle(pane, output)\n\t}\n}\n\nMalformed or unknown notifications yield their error and iteration continues.\nEvery other error ends the stream after being yielded, including the\n[ErrControlStreamLost] or os.ErrClosed [ControlClient.NextNotification]\nreports at a natural end.\n\nLeaving early preserves queued notifications for the next read."},"source":{"file":"tmux/control_stream.go","line":89,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlClient.Notifications","product":"core","slug":"tmux-controlclient-notifications"},{"id":"tmux.DisplayMessageRequest","name":"DisplayMessageRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DisplayMessageRequest configures display-message options shared by server, window, and pane scope. A zero request displays tmux's default message and returns nil. Print returns an owned stdout slice instead of displaying only to a client status line. Nil pointer fields omit their flags while pointers to empty values are explicit; a zero TargetClient omits its flag."},"source":{"file":"tmux/display_message.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest","product":"core","slug":"tmux-displaymessagerequest"},{"id":"tmux.DisplayMessageRequest.Message","name":"Message","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"string","doc":{"summary":"Message is the optional status message; an empty message leaves tmux's default behavior."},"source":{"file":"tmux/display_message.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.Message","product":"core","slug":"tmux-displaymessagerequest-message"},{"id":"tmux.DisplayMessageRequest.Print","name":"Print","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"Print returns message output instead of only displaying it."},"source":{"file":"tmux/display_message.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.Print","product":"core","slug":"tmux-displaymessagerequest-print"},{"id":"tmux.DisplayMessageRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"*string","doc":{"summary":"Format selects tmux output formatting."},"source":{"file":"tmux/display_message.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.Format","product":"core","slug":"tmux-displaymessagerequest-format"},{"id":"tmux.DisplayMessageRequest.AllFormats","name":"AllFormats","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"AllFormats includes every available format value."},"source":{"file":"tmux/display_message.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.AllFormats","product":"core","slug":"tmux-displaymessagerequest-allformats"},{"id":"tmux.DisplayMessageRequest.Verbose","name":"Verbose","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"Verbose requests verbose tmux output."},"source":{"file":"tmux/display_message.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.Verbose","product":"core","slug":"tmux-displaymessagerequest-verbose"},{"id":"tmux.DisplayMessageRequest.NoExpand","name":"NoExpand","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"NoExpand disables format expansion and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/display_message.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.NoExpand","product":"core","slug":"tmux-displaymessagerequest-noexpand"},{"id":"tmux.DisplayMessageRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the stable client receiving the display; zero omits -c."},"source":{"file":"tmux/display_message.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.TargetClient","product":"core","slug":"tmux-displaymessagerequest-targetclient"},{"id":"tmux.DisplayMessageRequest.Delay","name":"Delay","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"*time.Duration","doc":{"summary":"Delay sets the display duration. Nil uses tmux's display-time option; an explicit zero waits for a key press unless Notify is set. Values must be whole milliseconds from zero through 4294967295 milliseconds. Invalid values return ErrInvalidServerCommandRequest before tmux I/O."},"source":{"file":"tmux/display_message.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.Delay","product":"core","slug":"tmux-displaymessagerequest-delay"},{"id":"tmux.DisplayMessageRequest.Notify","name":"Notify","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"Notify makes the status message ignore key presses, closing only once Delay elapses."},"source":{"file":"tmux/display_message.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMessageRequest.Notify","product":"core","slug":"tmux-displaymessagerequest-notify"},{"id":"tmux.PaneDisplayMessageRequest","name":"PaneDisplayMessageRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneDisplayMessageRequest adds the pane-only update behavior to the common display-message options."},"source":{"file":"tmux/display_message.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneDisplayMessageRequest","product":"core","slug":"tmux-panedisplaymessagerequest"},{"id":"tmux.PaneDisplayMessageRequest.UpdatePane","name":"UpdatePane","kind":"attribute","modifiers":[],"parent":"tmux.PaneDisplayMessageRequest","signatures":[],"type":"bool","doc":{"summary":"UpdatePane updates pane state and requires tmux 3.6; see UnsupportedPolicy."},"source":{"file":"tmux/display_message.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneDisplayMessageRequest.UpdatePane","product":"core","slug":"tmux-panedisplaymessagerequest-updatepane"},{"id":"tmux.Server.DisplayMessage","name":"DisplayMessage","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayMessageRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"DisplayMessage displays or prints a server-scoped tmux message. Print returns an owned stdout slice even when tmux exits nonzero; completed stderr is delivered synchronously through [WarningCommandStderr], not returned as a completed-error classification. Unsupported flags follow [UnsupportedPolicy]. Any warnings run on the caller goroutine before return. Cancellation does not prove display did not occur."},"source":{"file":"tmux/display_message.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.DisplayMessage","product":"core","slug":"tmux-server-displaymessage"},{"id":"tmux.Window.DisplayMessage","name":"DisplayMessage","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayMessageRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"DisplayMessage displays or prints a message at this window's exact target. Print returns an owned stdout slice even on a completed nonzero exit; completed stderr reaches [WarningHandler] as [WarningCommandStderr]. NoExpand follows [UnsupportedPolicy]. Warnings run synchronously before return; context cancellation does not prove display did not occur."},"source":{"file":"tmux/display_message.go","line":93,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.DisplayMessage","product":"core","slug":"tmux-window-displaymessage"},{"id":"tmux.Pane.DisplayMessage","name":"DisplayMessage","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PaneDisplayMessageRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"DisplayMessage displays or prints a message at this pane's exact target. Embedded NoExpand requires tmux 3.4 and UpdatePane requires tmux 3.6; each follows [UnsupportedPolicy]. Print returns an owned stdout slice even on a completed nonzero exit. Completed stderr synchronously reaches [WarningHandler] as [WarningCommandStderr], not an error; cancellation does not prove display or pane update did not occur."},"source":{"file":"tmux/display_message.go","line":114,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.DisplayMessage","product":"core","slug":"tmux-pane-displaymessage"},{"id":"tmux.ErrInvalidEnvironmentName","name":"ErrInvalidEnvironmentName","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidEnvironmentName identifies a name tmux cannot store."},"source":{"file":"tmux/environment.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidEnvironmentName","product":"core","slug":"tmux-errinvalidenvironmentname"},{"id":"tmux.ErrInvalidEnvironmentValue","name":"ErrInvalidEnvironmentValue","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidEnvironmentValue identifies a value the line-oriented read API cannot round-trip."},"source":{"file":"tmux/environment.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidEnvironmentValue","product":"core","slug":"tmux-errinvalidenvironmentvalue"},{"id":"tmux.ErrMalformedEnvironment","name":"ErrMalformedEnvironment","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedEnvironment identifies output that is not a tmux environment entry."},"source":{"file":"tmux/environment.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrMalformedEnvironment","product":"core","slug":"tmux-errmalformedenvironment"},{"id":"tmux.SetEnvironmentOptions","name":"SetEnvironmentOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetEnvironmentOptions controls tmux's value expansion and visibility flags. Its zero value stores Value literally and exposes it to child processes."},"source":{"file":"tmux/environment.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetEnvironmentOptions","product":"core","slug":"tmux-setenvironmentoptions"},{"id":"tmux.SetEnvironmentOptions.ExpandFormat","name":"ExpandFormat","kind":"attribute","modifiers":[],"parent":"tmux.SetEnvironmentOptions","signatures":[],"type":"bool","doc":{"summary":"ExpandFormat expands tmux format expressions in Value before storing it."},"source":{"file":"tmux/environment.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetEnvironmentOptions.ExpandFormat","product":"core","slug":"tmux-setenvironmentoptions-expandformat"},{"id":"tmux.SetEnvironmentOptions.Hidden","name":"Hidden","kind":"attribute","modifiers":[],"parent":"tmux.SetEnvironmentOptions","signatures":[],"type":"bool","doc":{"summary":"Hidden keeps the value available to tmux but out of child environments."},"source":{"file":"tmux/environment.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetEnvironmentOptions.Hidden","product":"core","slug":"tmux-setenvironmentoptions-hidden"},{"id":"tmux.EnvironmentValue","name":"EnvironmentValue","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"EnvironmentValue is one tmux environment value or removal marker. Its zero value is an ordinary empty value, not a removal marker."},"source":{"file":"tmux/environment.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentValue","product":"core","slug":"tmux-environmentvalue"},{"id":"tmux.EnvironmentValue.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentValue","signatures":[],"type":"string","doc":{"summary":"Value is the exact value after tmux format expansion, if any."},"source":{"file":"tmux/environment.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentValue.Value","product":"core","slug":"tmux-environmentvalue-value"},{"id":"tmux.EnvironmentValue.Removed","name":"Removed","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentValue","signatures":[],"type":"bool","doc":{"summary":"Removed reports that tmux will remove the variable from new processes."},"source":{"file":"tmux/environment.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentValue.Removed","product":"core","slug":"tmux-environmentvalue-removed"},{"id":"tmux.EnvironmentNameError","name":"EnvironmentNameError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"EnvironmentNameError reports a name that tmux cannot store."},"source":{"file":"tmux/environment.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentNameError","product":"core","slug":"tmux-environmentnameerror"},{"id":"tmux.EnvironmentNameError.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentNameError","signatures":[],"type":"string","doc":{"summary":"Name is the invalid environment variable name."},"source":{"file":"tmux/environment.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentNameError.Name","product":"core","slug":"tmux-environmentnameerror-name"},{"id":"tmux.EnvironmentNameError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.EnvironmentNameError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/environment.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentNameError.Error","product":"core","slug":"tmux-environmentnameerror-error"},{"id":"tmux.EnvironmentNameError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.EnvironmentNameError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes EnvironmentNameError compatible with ErrInvalidEnvironmentName."},"source":{"file":"tmux/environment.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentNameError.Unwrap","product":"core","slug":"tmux-environmentnameerror-unwrap"},{"id":"tmux.EnvironmentValueError","name":"EnvironmentValueError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"EnvironmentValueError reports a value that cannot round-trip through show-environment. It intentionally does not retain or print the environment value."},"source":{"file":"tmux/environment.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentValueError","product":"core","slug":"tmux-environmentvalueerror"},{"id":"tmux.EnvironmentValueError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.EnvironmentValueError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error without disclosing the environment value."},"source":{"file":"tmux/environment.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentValueError.Error","product":"core","slug":"tmux-environmentvalueerror-error"},{"id":"tmux.EnvironmentValueError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.EnvironmentValueError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes EnvironmentValueError compatible with ErrInvalidEnvironmentValue."},"source":{"file":"tmux/environment.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentValueError.Unwrap","product":"core","slug":"tmux-environmentvalueerror-unwrap"},{"id":"tmux.EnvironmentDecodeError","name":"EnvironmentDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"EnvironmentDecodeError reports one malformed show-environment record. It never retains the record because environment output may contain secrets."},"source":{"file":"tmux/environment.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentDecodeError","product":"core","slug":"tmux-environmentdecodeerror"},{"id":"tmux.EnvironmentDecodeError.Record","name":"Record","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentDecodeError","signatures":[],"type":"int","doc":{"summary":"Record is the zero-based malformed output record number."},"source":{"file":"tmux/environment.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentDecodeError.Record","product":"core","slug":"tmux-environmentdecodeerror-record"},{"id":"tmux.EnvironmentDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.EnvironmentDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes malformed framing without retaining the record value."},"source":{"file":"tmux/environment.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentDecodeError.Reason","product":"core","slug":"tmux-environmentdecodeerror-reason"},{"id":"tmux.EnvironmentDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.EnvironmentDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/environment.go","line":73,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentDecodeError.Error","product":"core","slug":"tmux-environmentdecodeerror-error"},{"id":"tmux.EnvironmentDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.EnvironmentDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes EnvironmentDecodeError compatible with ErrMalformedEnvironment."},"source":{"file":"tmux/environment.go","line":78,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.EnvironmentDecodeError.Unwrap","product":"core","slug":"tmux-environmentdecodeerror-unwrap"},{"id":"tmux.Server.SetEnvironment","name":"SetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetEnvironmentOptions"}],"returns":"error"}],"doc":{"summary":"SetEnvironment stores a value in the server's global tmux environment. ExpandFormat and Hidden select tmux flags; cancellation does not prove the value was not stored."},"source":{"file":"tmux/environment.go","line":83,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetEnvironment","product":"core","slug":"tmux-server-setenvironment"},{"id":"tmux.Server.UnsetEnvironment","name":"UnsetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetEnvironment deletes a value from the server's global tmux environment. Cancellation does not prove deletion did not occur."},"source":{"file":"tmux/environment.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.UnsetEnvironment","product":"core","slug":"tmux-server-unsetenvironment"},{"id":"tmux.Server.RemoveEnvironment","name":"RemoveEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RemoveEnvironment marks a variable for removal from new process environments."},"source":{"file":"tmux/environment.go","line":99,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.RemoveEnvironment","product":"core","slug":"tmux-server-removeenvironment"},{"id":"tmux.Server.ShowEnvironment","name":"ShowEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(map[string]EnvironmentValue, error)"}],"doc":{"summary":"ShowEnvironment returns an owned server-global non-hidden tmux environment. Completed command failures return an empty map unless strict errors are enabled. Externally injected multiline entries return ErrMalformedEnvironment because tmux's multi-entry output does not frame continuation lines. Decode errors are compatible with [ErrMalformedEnvironment] and return no partial map."},"source":{"file":"tmux/environment.go","line":108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ShowEnvironment","product":"core","slug":"tmux-server-showenvironment"},{"id":"tmux.Server.GetEnvironment","name":"GetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(EnvironmentValue, bool, error)"}],"doc":{"summary":"GetEnvironment returns one non-hidden global environment entry. A missing or hidden variable reports ok false."},"source":{"file":"tmux/environment.go","line":114,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.GetEnvironment","product":"core","slug":"tmux-server-getenvironment"},{"id":"tmux.Session.SetEnvironment","name":"SetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetEnvironmentOptions"}],"returns":"error"}],"doc":{"summary":"SetEnvironment stores a value in this session's tmux environment, targeted by its stable SessionID."},"source":{"file":"tmux/environment.go","line":123,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetEnvironment","product":"core","slug":"tmux-session-setenvironment"},{"id":"tmux.Session.UnsetEnvironment","name":"UnsetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetEnvironment deletes a value from this session's tmux environment, targeted by its stable SessionID."},"source":{"file":"tmux/environment.go","line":138,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.UnsetEnvironment","product":"core","slug":"tmux-session-unsetenvironment"},{"id":"tmux.Session.RemoveEnvironment","name":"RemoveEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RemoveEnvironment marks a variable for removal from new process environments for this stable session target."},"source":{"file":"tmux/environment.go","line":148,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.RemoveEnvironment","product":"core","slug":"tmux-session-removeenvironment"},{"id":"tmux.Session.ShowEnvironment","name":"ShowEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(map[string]EnvironmentValue, error)"}],"doc":{"summary":"ShowEnvironment returns an owned session-scoped non-hidden tmux environment. Completed command failures return an empty map unless strict errors are enabled. Externally injected multiline entries return ErrMalformedEnvironment because tmux's multi-entry output does not frame continuation lines. Decode errors are compatible with [ErrMalformedEnvironment] and return no partial map."},"source":{"file":"tmux/environment.go","line":161,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ShowEnvironment","product":"core","slug":"tmux-session-showenvironment"},{"id":"tmux.Session.GetEnvironment","name":"GetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(EnvironmentValue, bool, error)"}],"doc":{"summary":"GetEnvironment returns one non-hidden session environment entry for this stable session target. A missing or hidden variable reports ok false."},"source":{"file":"tmux/environment.go","line":172,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.GetEnvironment","product":"core","slug":"tmux-session-getenvironment"},{"id":"tmux.ErrInvalidFilter","name":"ErrInvalidFilter","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidFilter reports a malformed or impossible generated filter. Filter validation, lookup parsing, predicates, and JSON methods wrap this error."},"source":{"file":"tmux/filter.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidFilter","product":"core","slug":"tmux-errinvalidfilter"},{"id":"tmux.Ptr","name":"Ptr","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"T"}],"returns":"*T","typeParams":["T any"]}],"doc":{"summary":"Ptr returns a distinct pointer to a shallow copy of value, including when T has zero size. Its nonzero holder prevents Go from coalescing zero-size addresses. Slices, maps, pointers, and other reference-bearing values still alias their referenced data. Ptr performs no validation or ownership transfer."},"source":{"file":"tmux/filter.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Ptr","product":"core","slug":"tmux-ptr"},{"id":"tmux.FilterSchemaVersion","name":"FilterSchemaVersion","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"FilterSchemaVersion identifies external metadata for the generated filter JSON wire schema. It is not embedded in JSON and is independent of the tmux [Version]."},"source":{"file":"tmux/filter_generated.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FilterSchemaVersion","product":"core","slug":"tmux-filterschemaversion"},{"id":"tmux.SessionFilter","name":"SessionFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionFilter matches materialized [Session] values without tmux I/O. Its zero value matches every non-nil candidate. Criteria are ANDed; AnyOf adds an OR requirement and Not excludes. Field and relation criteria correspond to [Session.ID], [Session.Name], [Session.Attached], [Session.Windows], and [Session.Panes]. [SessionFilter.Validate] and methods that consume the filter reject invalid criteria with [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter","product":"core","slug":"tmux-sessionfilter"},{"id":"tmux.SessionFilter.ID","name":"ID","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*SessionID","doc":{"summary":"ID exactly matches the stable tmux session identifier from Session.ID, including its $ sigil. A nil pointer leaves ID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.ID","product":"core","slug":"tmux-sessionfilter-id"},{"id":"tmux.SessionFilter.IDIn","name":"IDIn","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"[]SessionID","doc":{"summary":"IDIn lists accepted values for the stable tmux session identifier from Session.ID, including its $ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves IDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.IDIn","product":"core","slug":"tmux-sessionfilter-idin"},{"id":"tmux.SessionFilter.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*string","doc":{"summary":"Name exactly matches the materialized session name from Session.Name. A nil pointer leaves Name unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.Name","product":"core","slug":"tmux-sessionfilter-name"},{"id":"tmux.SessionFilter.NameIn","name":"NameIn","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"[]string","doc":{"summary":"NameIn lists accepted values for the materialized session name from Session.Name. A candidate matches when its materialized value equals one listed value. A nil slice leaves NameIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.NameIn","product":"core","slug":"tmux-sessionfilter-namein"},{"id":"tmux.SessionFilter.NameContains","name":"NameContains","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*string","doc":{"summary":"NameContains requires the materialized session name from Session.Name to contain the pointed-to substring. A nil pointer leaves NameContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.NameContains","product":"core","slug":"tmux-sessionfilter-namecontains"},{"id":"tmux.SessionFilter.NameRegex","name":"NameRegex","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"string","doc":{"summary":"NameRegex requires the materialized session name from Session.Name to match Go regular expression syntax. An empty string leaves NameRegex unset."},"source":{"file":"tmux/filter_generated.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.NameRegex","product":"core","slug":"tmux-sessionfilter-nameregex"},{"id":"tmux.SessionFilter.Attached","name":"Attached","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*bool","doc":{"summary":"Attached exactly matches the materialized attachment state from Session.Attached. A nil pointer leaves Attached unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.Attached","product":"core","slug":"tmux-sessionfilter-attached"},{"id":"tmux.SessionFilter.AnyOf","name":"AnyOf","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"[]SessionFilter","doc":{"summary":"AnyOf additionally requires at least one branch to match after ordinary criteria match. A nil slice leaves AnyOf unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.AnyOf","product":"core","slug":"tmux-sessionfilter-anyof"},{"id":"tmux.SessionFilter.Not","name":"Not","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*SessionFilter","doc":{"summary":"Not excludes a candidate when its nested filter matches. A nil pointer leaves Not unset."},"source":{"file":"tmux/filter_generated.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.Not","product":"core","slug":"tmux-sessionfilter-not"},{"id":"tmux.SessionFilter.Windows","name":"Windows","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*WindowRel","doc":{"summary":"Windows traverses the materialized window views returned by Session.Windows. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.Windows","product":"core","slug":"tmux-sessionfilter-windows"},{"id":"tmux.SessionFilter.Panes","name":"Panes","kind":"attribute","modifiers":[],"parent":"tmux.SessionFilter","signatures":[],"type":"*PaneRel","doc":{"summary":"Panes traverses the materialized pane views returned by Session.Panes. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.Panes","product":"core","slug":"tmux-sessionfilter-panes"},{"id":"tmux.WindowFilter","name":"WindowFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowFilter matches materialized [Window] values without tmux I/O. Its zero value matches every non-nil candidate. Criteria are ANDed; AnyOf adds an OR requirement and Not excludes. Field and relation criteria correspond to [Window.SessionID], [Window.ID], [Window.Index], [Window.Name], [Window.Active], [Window.Session], and [Window.Panes]. [WindowFilter.Validate] and methods that consume the filter reject invalid criteria with [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter","product":"core","slug":"tmux-windowfilter"},{"id":"tmux.WindowFilter.SessionID","name":"SessionID","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*SessionID","doc":{"summary":"SessionID exactly matches the stable tmux session identifier from Window.SessionID, including its $ sigil. A nil pointer leaves SessionID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.SessionID","product":"core","slug":"tmux-windowfilter-sessionid"},{"id":"tmux.WindowFilter.SessionIDIn","name":"SessionIDIn","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]SessionID","doc":{"summary":"SessionIDIn lists accepted values for the stable tmux session identifier from Window.SessionID, including its $ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves SessionIDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.SessionIDIn","product":"core","slug":"tmux-windowfilter-sessionidin"},{"id":"tmux.WindowFilter.ID","name":"ID","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*WindowID","doc":{"summary":"ID exactly matches the stable tmux window identifier from Window.ID, including its @ sigil. A nil pointer leaves ID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.ID","product":"core","slug":"tmux-windowfilter-id"},{"id":"tmux.WindowFilter.IDIn","name":"IDIn","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]WindowID","doc":{"summary":"IDIn lists accepted values for the stable tmux window identifier from Window.ID, including its @ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves IDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.IDIn","product":"core","slug":"tmux-windowfilter-idin"},{"id":"tmux.WindowFilter.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"Index exactly matches the nonnegative winlink index from Window.Index. A nil pointer leaves Index unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.Index","product":"core","slug":"tmux-windowfilter-index"},{"id":"tmux.WindowFilter.IndexIn","name":"IndexIn","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]int","doc":{"summary":"IndexIn lists accepted values for the nonnegative winlink index from Window.Index. A candidate matches when its materialized value equals one listed value. A nil slice leaves IndexIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":62,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.IndexIn","product":"core","slug":"tmux-windowfilter-indexin"},{"id":"tmux.WindowFilter.IndexGT","name":"IndexGT","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"IndexGT requires the nonnegative winlink index from Window.Index to be strictly greater than the pointed-to value. A nil pointer leaves IndexGT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":64,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.IndexGT","product":"core","slug":"tmux-windowfilter-indexgt"},{"id":"tmux.WindowFilter.IndexGTE","name":"IndexGTE","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"IndexGTE requires the nonnegative winlink index from Window.Index to be greater than or equal to the pointed-to value. A nil pointer leaves IndexGTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":66,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.IndexGTE","product":"core","slug":"tmux-windowfilter-indexgte"},{"id":"tmux.WindowFilter.IndexLT","name":"IndexLT","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"IndexLT requires the nonnegative winlink index from Window.Index to be strictly less than the pointed-to value. A nil pointer leaves IndexLT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":68,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.IndexLT","product":"core","slug":"tmux-windowfilter-indexlt"},{"id":"tmux.WindowFilter.IndexLTE","name":"IndexLTE","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*int","doc":{"summary":"IndexLTE requires the nonnegative winlink index from Window.Index to be less than or equal to the pointed-to value. A nil pointer leaves IndexLTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.IndexLTE","product":"core","slug":"tmux-windowfilter-indexlte"},{"id":"tmux.WindowFilter.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*string","doc":{"summary":"Name exactly matches the materialized window name from Window.Name. A nil pointer leaves Name unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":72,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.Name","product":"core","slug":"tmux-windowfilter-name"},{"id":"tmux.WindowFilter.NameIn","name":"NameIn","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]string","doc":{"summary":"NameIn lists accepted values for the materialized window name from Window.Name. A candidate matches when its materialized value equals one listed value. A nil slice leaves NameIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.NameIn","product":"core","slug":"tmux-windowfilter-namein"},{"id":"tmux.WindowFilter.NameContains","name":"NameContains","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*string","doc":{"summary":"NameContains requires the materialized window name from Window.Name to contain the pointed-to substring. A nil pointer leaves NameContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.NameContains","product":"core","slug":"tmux-windowfilter-namecontains"},{"id":"tmux.WindowFilter.NameRegex","name":"NameRegex","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"string","doc":{"summary":"NameRegex requires the materialized window name from Window.Name to match Go regular expression syntax. An empty string leaves NameRegex unset."},"source":{"file":"tmux/filter_generated.go","line":78,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.NameRegex","product":"core","slug":"tmux-windowfilter-nameregex"},{"id":"tmux.WindowFilter.Active","name":"Active","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*bool","doc":{"summary":"Active exactly matches the materialized active state from Window.Active. A nil pointer leaves Active unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.Active","product":"core","slug":"tmux-windowfilter-active"},{"id":"tmux.WindowFilter.AnyOf","name":"AnyOf","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"[]WindowFilter","doc":{"summary":"AnyOf additionally requires at least one branch to match after ordinary criteria match. A nil slice leaves AnyOf unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.AnyOf","product":"core","slug":"tmux-windowfilter-anyof"},{"id":"tmux.WindowFilter.Not","name":"Not","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*WindowFilter","doc":{"summary":"Not excludes a candidate when its nested filter matches. A nil pointer leaves Not unset."},"source":{"file":"tmux/filter_generated.go","line":84,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.Not","product":"core","slug":"tmux-windowfilter-not"},{"id":"tmux.WindowFilter.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*SessionFilter","doc":{"summary":"Session traverses the materialized parent returned by Window.Session. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":86,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.Session","product":"core","slug":"tmux-windowfilter-session"},{"id":"tmux.WindowFilter.Panes","name":"Panes","kind":"attribute","modifiers":[],"parent":"tmux.WindowFilter","signatures":[],"type":"*PaneRel","doc":{"summary":"Panes traverses the materialized pane views returned by Window.Panes. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.Panes","product":"core","slug":"tmux-windowfilter-panes"},{"id":"tmux.PaneFilter","name":"PaneFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneFilter matches materialized [Pane] values without tmux I/O. Its zero value matches every non-nil candidate. Criteria are ANDed; AnyOf adds an OR requirement and Not excludes. Field and relation criteria correspond to [Pane.SessionID], [Pane.WindowID], [Pane.ID], [Pane.WindowIndex], [Pane.Index], [Pane.CurrentCommand], [Pane.Active], [Pane.Title], [Pane.Session], and [Pane.Window]. [PaneFilter.Validate] and methods that consume the filter reject invalid criteria with [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":95,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter","product":"core","slug":"tmux-panefilter"},{"id":"tmux.PaneFilter.SessionID","name":"SessionID","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*SessionID","doc":{"summary":"SessionID exactly matches the stable tmux session identifier from Pane.SessionID, including its $ sigil. A nil pointer leaves SessionID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":97,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.SessionID","product":"core","slug":"tmux-panefilter-sessionid"},{"id":"tmux.PaneFilter.SessionIDIn","name":"SessionIDIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]SessionID","doc":{"summary":"SessionIDIn lists accepted values for the stable tmux session identifier from Pane.SessionID, including its $ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves SessionIDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":99,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.SessionIDIn","product":"core","slug":"tmux-panefilter-sessionidin"},{"id":"tmux.PaneFilter.WindowID","name":"WindowID","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*WindowID","doc":{"summary":"WindowID exactly matches the stable tmux window identifier from Pane.WindowID, including its @ sigil. A nil pointer leaves WindowID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":101,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.WindowID","product":"core","slug":"tmux-panefilter-windowid"},{"id":"tmux.PaneFilter.WindowIDIn","name":"WindowIDIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]WindowID","doc":{"summary":"WindowIDIn lists accepted values for the stable tmux window identifier from Pane.WindowID, including its @ sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves WindowIDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":103,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.WindowIDIn","product":"core","slug":"tmux-panefilter-windowidin"},{"id":"tmux.PaneFilter.ID","name":"ID","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*PaneID","doc":{"summary":"ID exactly matches the stable tmux pane identifier from Pane.ID, including its % sigil. A nil pointer leaves ID unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":105,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.ID","product":"core","slug":"tmux-panefilter-id"},{"id":"tmux.PaneFilter.IDIn","name":"IDIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]PaneID","doc":{"summary":"IDIn lists accepted values for the stable tmux pane identifier from Pane.ID, including its % sigil. A candidate matches when its materialized value equals one listed value. A nil slice leaves IDIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":107,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.IDIn","product":"core","slug":"tmux-panefilter-idin"},{"id":"tmux.PaneFilter.WindowIndex","name":"WindowIndex","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndex exactly matches the nonnegative winlink index from Pane.WindowIndex. A nil pointer leaves WindowIndex unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":109,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.WindowIndex","product":"core","slug":"tmux-panefilter-windowindex"},{"id":"tmux.PaneFilter.WindowIndexIn","name":"WindowIndexIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]int","doc":{"summary":"WindowIndexIn lists accepted values for the nonnegative winlink index from Pane.WindowIndex. A candidate matches when its materialized value equals one listed value. A nil slice leaves WindowIndexIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.WindowIndexIn","product":"core","slug":"tmux-panefilter-windowindexin"},{"id":"tmux.PaneFilter.WindowIndexGT","name":"WindowIndexGT","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndexGT requires the nonnegative winlink index from Pane.WindowIndex to be strictly greater than the pointed-to value. A nil pointer leaves WindowIndexGT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":113,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.WindowIndexGT","product":"core","slug":"tmux-panefilter-windowindexgt"},{"id":"tmux.PaneFilter.WindowIndexGTE","name":"WindowIndexGTE","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndexGTE requires the nonnegative winlink index from Pane.WindowIndex to be greater than or equal to the pointed-to value. A nil pointer leaves WindowIndexGTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":115,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.WindowIndexGTE","product":"core","slug":"tmux-panefilter-windowindexgte"},{"id":"tmux.PaneFilter.WindowIndexLT","name":"WindowIndexLT","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndexLT requires the nonnegative winlink index from Pane.WindowIndex to be strictly less than the pointed-to value. A nil pointer leaves WindowIndexLT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":117,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.WindowIndexLT","product":"core","slug":"tmux-panefilter-windowindexlt"},{"id":"tmux.PaneFilter.WindowIndexLTE","name":"WindowIndexLTE","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"WindowIndexLTE requires the nonnegative winlink index from Pane.WindowIndex to be less than or equal to the pointed-to value. A nil pointer leaves WindowIndexLTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":119,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.WindowIndexLTE","product":"core","slug":"tmux-panefilter-windowindexlte"},{"id":"tmux.PaneFilter.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"Index exactly matches the nonnegative pane index from Pane.Index. A nil pointer leaves Index unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":121,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Index","product":"core","slug":"tmux-panefilter-index"},{"id":"tmux.PaneFilter.IndexIn","name":"IndexIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]int","doc":{"summary":"IndexIn lists accepted values for the nonnegative pane index from Pane.Index. A candidate matches when its materialized value equals one listed value. A nil slice leaves IndexIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":123,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.IndexIn","product":"core","slug":"tmux-panefilter-indexin"},{"id":"tmux.PaneFilter.IndexGT","name":"IndexGT","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"IndexGT requires the nonnegative pane index from Pane.Index to be strictly greater than the pointed-to value. A nil pointer leaves IndexGT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":125,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.IndexGT","product":"core","slug":"tmux-panefilter-indexgt"},{"id":"tmux.PaneFilter.IndexGTE","name":"IndexGTE","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"IndexGTE requires the nonnegative pane index from Pane.Index to be greater than or equal to the pointed-to value. A nil pointer leaves IndexGTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":127,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.IndexGTE","product":"core","slug":"tmux-panefilter-indexgte"},{"id":"tmux.PaneFilter.IndexLT","name":"IndexLT","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"IndexLT requires the nonnegative pane index from Pane.Index to be strictly less than the pointed-to value. A nil pointer leaves IndexLT unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":129,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.IndexLT","product":"core","slug":"tmux-panefilter-indexlt"},{"id":"tmux.PaneFilter.IndexLTE","name":"IndexLTE","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*int","doc":{"summary":"IndexLTE requires the nonnegative pane index from Pane.Index to be less than or equal to the pointed-to value. A nil pointer leaves IndexLTE unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":131,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.IndexLTE","product":"core","slug":"tmux-panefilter-indexlte"},{"id":"tmux.PaneFilter.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*string","doc":{"summary":"Command exactly matches the materialized current command from Pane.CurrentCommand. A nil pointer leaves Command unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":133,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Command","product":"core","slug":"tmux-panefilter-command"},{"id":"tmux.PaneFilter.CommandIn","name":"CommandIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]string","doc":{"summary":"CommandIn lists accepted values for the materialized current command from Pane.CurrentCommand. A candidate matches when its materialized value equals one listed value. A nil slice leaves CommandIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":135,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.CommandIn","product":"core","slug":"tmux-panefilter-commandin"},{"id":"tmux.PaneFilter.CommandContains","name":"CommandContains","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*string","doc":{"summary":"CommandContains requires the materialized current command from Pane.CurrentCommand to contain the pointed-to substring. A nil pointer leaves CommandContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":137,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.CommandContains","product":"core","slug":"tmux-panefilter-commandcontains"},{"id":"tmux.PaneFilter.CommandRegex","name":"CommandRegex","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"string","doc":{"summary":"CommandRegex requires the materialized current command from Pane.CurrentCommand to match Go regular expression syntax. An empty string leaves CommandRegex unset."},"source":{"file":"tmux/filter_generated.go","line":139,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.CommandRegex","product":"core","slug":"tmux-panefilter-commandregex"},{"id":"tmux.PaneFilter.Active","name":"Active","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*bool","doc":{"summary":"Active exactly matches the materialized active state from Pane.Active. A nil pointer leaves Active unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":141,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Active","product":"core","slug":"tmux-panefilter-active"},{"id":"tmux.PaneFilter.Title","name":"Title","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*string","doc":{"summary":"Title exactly matches the materialized title from Pane.Title. A nil pointer leaves Title unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":143,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Title","product":"core","slug":"tmux-panefilter-title"},{"id":"tmux.PaneFilter.TitleIn","name":"TitleIn","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]string","doc":{"summary":"TitleIn lists accepted values for the materialized title from Pane.Title. A candidate matches when its materialized value equals one listed value. A nil slice leaves TitleIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":145,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.TitleIn","product":"core","slug":"tmux-panefilter-titlein"},{"id":"tmux.PaneFilter.TitleContains","name":"TitleContains","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*string","doc":{"summary":"TitleContains requires the materialized title from Pane.Title to contain the pointed-to substring. A nil pointer leaves TitleContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":147,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.TitleContains","product":"core","slug":"tmux-panefilter-titlecontains"},{"id":"tmux.PaneFilter.TitleRegex","name":"TitleRegex","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"string","doc":{"summary":"TitleRegex requires the materialized title from Pane.Title to match Go regular expression syntax. An empty string leaves TitleRegex unset."},"source":{"file":"tmux/filter_generated.go","line":149,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.TitleRegex","product":"core","slug":"tmux-panefilter-titleregex"},{"id":"tmux.PaneFilter.AnyOf","name":"AnyOf","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"[]PaneFilter","doc":{"summary":"AnyOf additionally requires at least one branch to match after ordinary criteria match. A nil slice leaves AnyOf unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":151,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.AnyOf","product":"core","slug":"tmux-panefilter-anyof"},{"id":"tmux.PaneFilter.Not","name":"Not","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*PaneFilter","doc":{"summary":"Not excludes a candidate when its nested filter matches. A nil pointer leaves Not unset."},"source":{"file":"tmux/filter_generated.go","line":153,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Not","product":"core","slug":"tmux-panefilter-not"},{"id":"tmux.PaneFilter.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*SessionFilter","doc":{"summary":"Session traverses the materialized parent returned by Pane.Session. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":155,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Session","product":"core","slug":"tmux-panefilter-session"},{"id":"tmux.PaneFilter.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.PaneFilter","signatures":[],"type":"*WindowFilter","doc":{"summary":"Window traverses the materialized parent returned by Pane.Window. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":157,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Window","product":"core","slug":"tmux-panefilter-window"},{"id":"tmux.ClientFilter","name":"ClientFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClientFilter matches materialized [Client] values without tmux I/O. Its zero value matches every non-nil candidate. Criteria are ANDed; AnyOf adds an OR requirement and Not excludes. Field and relation criteria correspond to [Client.Name], [Client.ReadOnly], [Client.AttachedSession], [Client.AttachedWindow], and [Client.AttachedPane]. [ClientFilter.Validate] and methods that consume the filter reject invalid criteria with [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":164,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter","product":"core","slug":"tmux-clientfilter"},{"id":"tmux.ClientFilter.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*ClientName","doc":{"summary":"Name exactly matches the stable tmux client name from Client.Name. A nil pointer leaves Name unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":166,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.Name","product":"core","slug":"tmux-clientfilter-name"},{"id":"tmux.ClientFilter.NameIn","name":"NameIn","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"[]ClientName","doc":{"summary":"NameIn lists accepted values for the stable tmux client name from Client.Name. A candidate matches when its materialized value equals one listed value. A nil slice leaves NameIn unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":168,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.NameIn","product":"core","slug":"tmux-clientfilter-namein"},{"id":"tmux.ClientFilter.NameContains","name":"NameContains","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*string","doc":{"summary":"NameContains requires the stable tmux client name from Client.Name to contain the pointed-to substring. A nil pointer leaves NameContains unset; a non-nil pointer applies it, and an empty string matches every available string."},"source":{"file":"tmux/filter_generated.go","line":170,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.NameContains","product":"core","slug":"tmux-clientfilter-namecontains"},{"id":"tmux.ClientFilter.NameRegex","name":"NameRegex","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"string","doc":{"summary":"NameRegex requires the stable tmux client name from Client.Name to match Go regular expression syntax. An empty string leaves NameRegex unset."},"source":{"file":"tmux/filter_generated.go","line":172,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.NameRegex","product":"core","slug":"tmux-clientfilter-nameregex"},{"id":"tmux.ClientFilter.ReadOnly","name":"ReadOnly","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*bool","doc":{"summary":"ReadOnly exactly matches the materialized read-only state from Client.ReadOnly. A nil pointer leaves ReadOnly unset; a non-nil pointer applies it, including when it points to the zero value."},"source":{"file":"tmux/filter_generated.go","line":174,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.ReadOnly","product":"core","slug":"tmux-clientfilter-readonly"},{"id":"tmux.ClientFilter.AnyOf","name":"AnyOf","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"[]ClientFilter","doc":{"summary":"AnyOf additionally requires at least one branch to match after ordinary criteria match. A nil slice leaves AnyOf unset; a non-nil empty slice is invalid."},"source":{"file":"tmux/filter_generated.go","line":176,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.AnyOf","product":"core","slug":"tmux-clientfilter-anyof"},{"id":"tmux.ClientFilter.Not","name":"Not","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*ClientFilter","doc":{"summary":"Not excludes a candidate when its nested filter matches. A nil pointer leaves Not unset."},"source":{"file":"tmux/filter_generated.go","line":178,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.Not","product":"core","slug":"tmux-clientfilter-not"},{"id":"tmux.ClientFilter.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*SessionFilter","doc":{"summary":"Session traverses the materialized attachment returned by Client.AttachedSession. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":180,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.Session","product":"core","slug":"tmux-clientfilter-session"},{"id":"tmux.ClientFilter.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*WindowFilter","doc":{"summary":"Window traverses the materialized attachment returned by Client.AttachedWindow. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":182,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.Window","product":"core","slug":"tmux-clientfilter-window"},{"id":"tmux.ClientFilter.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.ClientFilter","signatures":[],"type":"*PaneFilter","doc":{"summary":"Pane traverses the materialized attachment returned by Client.AttachedPane. A nil pointer leaves the relation criterion unset."},"source":{"file":"tmux/filter_generated.go","line":184,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.Pane","product":"core","slug":"tmux-clientfilter-pane"},{"id":"tmux.SessionIDIs","name":"SessionIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"SessionID"}],"returns":"SessionFilter"}],"doc":{"summary":"SessionIDIs returns a [SessionFilter] that exactly matches the stable tmux session identifier from Session.ID, including its $ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":188,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionIDIs","product":"core","slug":"tmux-sessionidis"},{"id":"tmux.SessionNameIs","name":"SessionNameIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"string"}],"returns":"SessionFilter"}],"doc":{"summary":"SessionNameIs returns a [SessionFilter] that exactly matches the materialized session name from Session.Name. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":193,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionNameIs","product":"core","slug":"tmux-sessionnameis"},{"id":"tmux.SessionAttachedIs","name":"SessionAttachedIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"bool"}],"returns":"SessionFilter"}],"doc":{"summary":"SessionAttachedIs returns a [SessionFilter] that exactly matches the materialized attachment state from Session.Attached. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":198,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionAttachedIs","product":"core","slug":"tmux-sessionattachedis"},{"id":"tmux.WindowSessionIDIs","name":"WindowSessionIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"SessionID"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowSessionIDIs returns a [WindowFilter] that exactly matches the stable tmux session identifier from Window.SessionID, including its $ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":203,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSessionIDIs","product":"core","slug":"tmux-windowsessionidis"},{"id":"tmux.WindowIDIs","name":"WindowIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"WindowID"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowIDIs returns a [WindowFilter] that exactly matches the stable tmux window identifier from Window.ID, including its @ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":208,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowIDIs","product":"core","slug":"tmux-windowidis"},{"id":"tmux.WindowIndexIs","name":"WindowIndexIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"int"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowIndexIs returns a [WindowFilter] that exactly matches the nonnegative winlink index from Window.Index. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":213,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowIndexIs","product":"core","slug":"tmux-windowindexis"},{"id":"tmux.WindowNameIs","name":"WindowNameIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"string"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowNameIs returns a [WindowFilter] that exactly matches the materialized window name from Window.Name. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":218,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowNameIs","product":"core","slug":"tmux-windownameis"},{"id":"tmux.WindowActiveIs","name":"WindowActiveIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"bool"}],"returns":"WindowFilter"}],"doc":{"summary":"WindowActiveIs returns a [WindowFilter] that exactly matches the materialized active state from Window.Active. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":223,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowActiveIs","product":"core","slug":"tmux-windowactiveis"},{"id":"tmux.PaneSessionIDIs","name":"PaneSessionIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"SessionID"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneSessionIDIs returns a [PaneFilter] that exactly matches the stable tmux session identifier from Pane.SessionID, including its $ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":228,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSessionIDIs","product":"core","slug":"tmux-panesessionidis"},{"id":"tmux.PaneWindowIDIs","name":"PaneWindowIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"WindowID"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneWindowIDIs returns a [PaneFilter] that exactly matches the stable tmux window identifier from Pane.WindowID, including its @ sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":233,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneWindowIDIs","product":"core","slug":"tmux-panewindowidis"},{"id":"tmux.PaneIDIs","name":"PaneIDIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"PaneID"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneIDIs returns a [PaneFilter] that exactly matches the stable tmux pane identifier from Pane.ID, including its % sigil. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":238,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneIDIs","product":"core","slug":"tmux-paneidis"},{"id":"tmux.PaneWindowIndexIs","name":"PaneWindowIndexIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"int"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneWindowIndexIs returns a [PaneFilter] that exactly matches the nonnegative winlink index from Pane.WindowIndex. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":243,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneWindowIndexIs","product":"core","slug":"tmux-panewindowindexis"},{"id":"tmux.PaneIndexIs","name":"PaneIndexIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"int"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneIndexIs returns a [PaneFilter] that exactly matches the nonnegative pane index from Pane.Index. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":248,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneIndexIs","product":"core","slug":"tmux-paneindexis"},{"id":"tmux.PaneCommandIs","name":"PaneCommandIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"string"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneCommandIs returns a [PaneFilter] that exactly matches the materialized current command from Pane.CurrentCommand. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":253,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneCommandIs","product":"core","slug":"tmux-panecommandis"},{"id":"tmux.PaneActiveIs","name":"PaneActiveIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"bool"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneActiveIs returns a [PaneFilter] that exactly matches the materialized active state from Pane.Active. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":258,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneActiveIs","product":"core","slug":"tmux-paneactiveis"},{"id":"tmux.PaneTitleIs","name":"PaneTitleIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"string"}],"returns":"PaneFilter"}],"doc":{"summary":"PaneTitleIs returns a [PaneFilter] that exactly matches the materialized title from Pane.Title. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":263,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneTitleIs","product":"core","slug":"tmux-panetitleis"},{"id":"tmux.ClientNameIs","name":"ClientNameIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"ClientName"}],"returns":"ClientFilter"}],"doc":{"summary":"ClientNameIs returns a [ClientFilter] that exactly matches the stable tmux client name from Client.Name. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":268,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientNameIs","product":"core","slug":"tmux-clientnameis"},{"id":"tmux.ClientReadOnlyIs","name":"ClientReadOnlyIs","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"value","type":"bool"}],"returns":"ClientFilter"}],"doc":{"summary":"ClientReadOnlyIs returns a [ClientFilter] that exactly matches the materialized read-only state from Client.ReadOnly. It sets no other criteria and does not validate value."},"source":{"file":"tmux/filter_generated.go","line":273,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientReadOnlyIs","product":"core","slug":"tmux-clientreadonlyis"},{"id":"tmux.WindowRel","name":"WindowRel","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowRel applies quantifiers to a materialized [Window] relation; its zero value is invalid. Some is existential, Every is universal and vacuously true for an empty relation, and None excludes; enabled quantifiers are conjunctive."},"source":{"file":"tmux/filter_generated.go","line":279,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowRel","product":"core","slug":"tmux-windowrel"},{"id":"tmux.WindowRel.Some","name":"Some","kind":"attribute","modifiers":[],"parent":"tmux.WindowRel","signatures":[],"type":"*WindowFilter","doc":{"summary":"Some requires an existential match: at least one related value must match."},"source":{"file":"tmux/filter_generated.go","line":281,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowRel.Some","product":"core","slug":"tmux-windowrel-some"},{"id":"tmux.WindowRel.Every","name":"Every","kind":"attribute","modifiers":[],"parent":"tmux.WindowRel","signatures":[],"type":"*WindowFilter","doc":{"summary":"Every requires a universal match and is vacuously true for an empty relation."},"source":{"file":"tmux/filter_generated.go","line":283,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowRel.Every","product":"core","slug":"tmux-windowrel-every"},{"id":"tmux.WindowRel.None","name":"None","kind":"attribute","modifiers":[],"parent":"tmux.WindowRel","signatures":[],"type":"*WindowFilter","doc":{"summary":"None excludes the candidate when any related value matches."},"source":{"file":"tmux/filter_generated.go","line":285,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowRel.None","product":"core","slug":"tmux-windowrel-none"},{"id":"tmux.PaneRel","name":"PaneRel","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneRel applies quantifiers to a materialized [Pane] relation; its zero value is invalid. Some is existential, Every is universal and vacuously true for an empty relation, and None excludes; enabled quantifiers are conjunctive."},"source":{"file":"tmux/filter_generated.go","line":290,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneRel","product":"core","slug":"tmux-panerel"},{"id":"tmux.PaneRel.Some","name":"Some","kind":"attribute","modifiers":[],"parent":"tmux.PaneRel","signatures":[],"type":"*PaneFilter","doc":{"summary":"Some requires an existential match: at least one related value must match."},"source":{"file":"tmux/filter_generated.go","line":292,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneRel.Some","product":"core","slug":"tmux-panerel-some"},{"id":"tmux.PaneRel.Every","name":"Every","kind":"attribute","modifiers":[],"parent":"tmux.PaneRel","signatures":[],"type":"*PaneFilter","doc":{"summary":"Every requires a universal match and is vacuously true for an empty relation."},"source":{"file":"tmux/filter_generated.go","line":294,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneRel.Every","product":"core","slug":"tmux-panerel-every"},{"id":"tmux.PaneRel.None","name":"None","kind":"attribute","modifiers":[],"parent":"tmux.PaneRel","signatures":[],"type":"*PaneFilter","doc":{"summary":"None excludes the candidate when any related value matches."},"source":{"file":"tmux/filter_generated.go","line":296,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneRel.None","product":"core","slug":"tmux-panerel-none"},{"id":"tmux.ParseSessionLookup","name":"ParseSessionLookup","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"lookup","type":"string"},{"name":"values","type":"string"}],"returns":"(SessionFilter, error)"}],"doc":{"summary":"ParseSessionLookup converts a lookup path into a concrete session filter. Paths traverse generated JSON relation names and separate segments with double underscores. The default operator is exact. Accepted suffixes are eq, exact, iexact, contains, icontains, startswith, istartswith, endswith, iendswith, in, nin, regex, and iregex; availability is field-specific. The eq suffix aliases exact, nin negates in, scalar operators require one value, and in and nin require one or more. Invalid paths, operators, values, or results wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":666,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ParseSessionLookup","product":"core","slug":"tmux-parsesessionlookup"},{"id":"tmux.ParseWindowLookup","name":"ParseWindowLookup","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"lookup","type":"string"},{"name":"values","type":"string"}],"returns":"(WindowFilter, error)"}],"doc":{"summary":"ParseWindowLookup converts a lookup path into a concrete window filter. Paths traverse generated JSON relation names and separate segments with double underscores. The default operator is exact. Accepted suffixes are eq, exact, iexact, contains, icontains, startswith, istartswith, endswith, iendswith, in, nin, regex, and iregex; availability is field-specific. The eq suffix aliases exact, nin negates in, scalar operators require one value, and in and nin require one or more. Invalid paths, operators, values, or results wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":690,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ParseWindowLookup","product":"core","slug":"tmux-parsewindowlookup"},{"id":"tmux.ParsePaneLookup","name":"ParsePaneLookup","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"lookup","type":"string"},{"name":"values","type":"string"}],"returns":"(PaneFilter, error)"}],"doc":{"summary":"ParsePaneLookup converts a lookup path into a concrete pane filter. Paths traverse generated JSON relation names and separate segments with double underscores. The default operator is exact. Accepted suffixes are eq, exact, iexact, contains, icontains, startswith, istartswith, endswith, iendswith, in, nin, regex, and iregex; availability is field-specific. The eq suffix aliases exact, nin negates in, scalar operators require one value, and in and nin require one or more. Invalid paths, operators, values, or results wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":714,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ParsePaneLookup","product":"core","slug":"tmux-parsepanelookup"},{"id":"tmux.ParseClientLookup","name":"ParseClientLookup","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"lookup","type":"string"},{"name":"values","type":"string"}],"returns":"(ClientFilter, error)"}],"doc":{"summary":"ParseClientLookup converts a lookup path into a concrete client filter. Paths traverse generated JSON relation names and separate segments with double underscores. The default operator is exact. Accepted suffixes are eq, exact, iexact, contains, icontains, startswith, istartswith, endswith, iendswith, in, nin, regex, and iregex; availability is field-specific. The eq suffix aliases exact, nin negates in, scalar operators require one value, and in and nin require one or more. Invalid paths, operators, values, or results wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":738,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ParseClientLookup","product":"core","slug":"tmux-parseclientlookup"},{"id":"tmux.SessionFilter.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.SessionFilter","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks structure, regular expressions, and contradictory criteria; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":1687,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.Validate","product":"core","slug":"tmux-sessionfilter-validate"},{"id":"tmux.WindowFilter.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.WindowFilter","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks structure, regular expressions, and contradictory criteria; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":1907,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.Validate","product":"core","slug":"tmux-windowfilter-validate"},{"id":"tmux.PaneFilter.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.PaneFilter","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks structure, regular expressions, and contradictory criteria; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2093,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Validate","product":"core","slug":"tmux-panefilter-validate"},{"id":"tmux.ClientFilter.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.ClientFilter","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks structure, regular expressions, and contradictory criteria; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2256,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.Validate","product":"core","slug":"tmux-clientfilter-validate"},{"id":"tmux.SessionFilter.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.SessionFilter","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the session filter; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2387,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.MarshalJSON","product":"core","slug":"tmux-sessionfilter-marshaljson"},{"id":"tmux.WindowFilter.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.WindowFilter","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the window filter; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2396,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.MarshalJSON","product":"core","slug":"tmux-windowfilter-marshaljson"},{"id":"tmux.PaneFilter.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.PaneFilter","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the pane filter; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2405,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.MarshalJSON","product":"core","slug":"tmux-panefilter-marshaljson"},{"id":"tmux.ClientFilter.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.ClientFilter","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the client filter; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2414,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.MarshalJSON","product":"core","slug":"tmux-clientfilter-marshaljson"},{"id":"tmux.WindowRel.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.WindowRel","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the window relation; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2445,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowRel.MarshalJSON","product":"core","slug":"tmux-windowrel-marshaljson"},{"id":"tmux.PaneRel.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.PaneRel","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON validates and encodes the pane relation; failures wrap [ErrInvalidFilter]."},"source":{"file":"tmux/filter_generated.go","line":2476,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneRel.MarshalJSON","product":"core","slug":"tmux-panerel-marshaljson"},{"id":"tmux.SessionFilter.Predicate","name":"Predicate","kind":"method","modifiers":[],"parent":"tmux.SessionFilter","signatures":[{"params":[],"returns":"(func(*Session) bool, error)"}],"doc":{"summary":"Predicate validates the session filter and returns a local predicate for [Session] values materialized by a [Snapshot]; it never runs tmux. It traverses only loaded relations and returns false for a nil candidate."},"source":{"file":"tmux/filter_generated.go","line":2486,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.Predicate","product":"core","slug":"tmux-sessionfilter-predicate"},{"id":"tmux.WindowFilter.Predicate","name":"Predicate","kind":"method","modifiers":[],"parent":"tmux.WindowFilter","signatures":[{"params":[],"returns":"(func(*Window) bool, error)"}],"doc":{"summary":"Predicate validates the window filter and returns a local predicate for [Window] values materialized by a [Snapshot]; it never runs tmux. It traverses only loaded relations and returns false for a nil candidate."},"source":{"file":"tmux/filter_generated.go","line":2720,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.Predicate","product":"core","slug":"tmux-windowfilter-predicate"},{"id":"tmux.PaneFilter.Predicate","name":"Predicate","kind":"method","modifiers":[],"parent":"tmux.PaneFilter","signatures":[{"params":[],"returns":"(func(*Pane) bool, error)"}],"doc":{"summary":"Predicate validates the pane filter and returns a local predicate for [Pane] values materialized by a [Snapshot]; it never runs tmux. It traverses only loaded relations and returns false for a nil candidate."},"source":{"file":"tmux/filter_generated.go","line":2979,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.Predicate","product":"core","slug":"tmux-panefilter-predicate"},{"id":"tmux.ClientFilter.Predicate","name":"Predicate","kind":"method","modifiers":[],"parent":"tmux.ClientFilter","signatures":[{"params":[],"returns":"(func(*Client) bool, error)"}],"doc":{"summary":"Predicate validates the client filter and returns a local predicate for [Client] values materialized by a [Snapshot]; it never runs tmux. It traverses only loaded relations and returns false for a nil candidate."},"source":{"file":"tmux/filter_generated.go","line":3304,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.Predicate","product":"core","slug":"tmux-clientfilter-predicate"},{"id":"tmux.SessionFilter.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.SessionFilter","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a session filter, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3446,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFilter.UnmarshalJSON","product":"core","slug":"tmux-sessionfilter-unmarshaljson"},{"id":"tmux.WindowFilter.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.WindowFilter","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a window filter, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3471,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFilter.UnmarshalJSON","product":"core","slug":"tmux-windowfilter-unmarshaljson"},{"id":"tmux.PaneFilter.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.PaneFilter","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a pane filter, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3504,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFilter.UnmarshalJSON","product":"core","slug":"tmux-panefilter-unmarshaljson"},{"id":"tmux.ClientFilter.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.ClientFilter","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a client filter, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3549,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientFilter.UnmarshalJSON","product":"core","slug":"tmux-clientfilter-unmarshaljson"},{"id":"tmux.WindowRel.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.WindowRel","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a window relation, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3573,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowRel.UnmarshalJSON","product":"core","slug":"tmux-windowrel-unmarshaljson"},{"id":"tmux.PaneRel.UnmarshalJSON","name":"UnmarshalJSON","kind":"method","modifiers":[],"parent":"tmux.PaneRel","signatures":[{"params":[{"name":"data","type":"[]byte"}],"returns":"error"}],"doc":{"summary":"UnmarshalJSON clears the receiver, strictly decodes a pane relation, then validates it. Unknown or duplicate fields, trailing data, and semantic failures wrap [ErrInvalidFilter]; the receiver may retain decoded state on error."},"source":{"file":"tmux/filter_generated.go","line":3590,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneRel.UnmarshalJSON","product":"core","slug":"tmux-panerel-unmarshaljson"},{"id":"tmux.ErrMalformedFormatOutput","name":"ErrMalformedFormatOutput","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedFormatOutput identifies invalid escaped tmux format output. It is matched by errors.Is for [FormatDecodeError]."},"source":{"file":"tmux/format.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrMalformedFormatOutput","product":"core","slug":"tmux-errmalformedformatoutput"},{"id":"tmux.FormatDecodeError","name":"FormatDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"FormatDecodeError identifies a malformed escaped tmux format record. It matches [ErrMalformedFormatOutput] through errors.Is; callers can recover its location fields with errors.As. Library-created errors do not retain decoded record values, which may contain caller data."},"source":{"file":"tmux/format.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatDecodeError","product":"core","slug":"tmux-formatdecodeerror"},{"id":"tmux.FormatDecodeError.Record","name":"Record","kind":"attribute","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[],"type":"int","doc":{"summary":"Record is the one-based physical record number."},"source":{"file":"tmux/format.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatDecodeError.Record","product":"core","slug":"tmux-formatdecodeerror-record"},{"id":"tmux.FormatDecodeError.Field","name":"Field","kind":"attribute","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[],"type":"string","doc":{"summary":"Field names the format field that could not be decoded."},"source":{"file":"tmux/format.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatDecodeError.Field","product":"core","slug":"tmux-formatdecodeerror-field"},{"id":"tmux.FormatDecodeError.Offset","name":"Offset","kind":"attribute","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[],"type":"int","doc":{"summary":"Offset is the zero-based byte offset within Field's encoded value."},"source":{"file":"tmux/format.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatDecodeError.Offset","product":"core","slug":"tmux-formatdecodeerror-offset"},{"id":"tmux.FormatDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes the malformed encoding."},"source":{"file":"tmux/format.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatDecodeError.Reason","product":"core","slug":"tmux-formatdecodeerror-reason"},{"id":"tmux.FormatDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/format.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatDecodeError.Error","product":"core","slug":"tmux-formatdecodeerror-error"},{"id":"tmux.FormatDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.FormatDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes FormatDecodeError compatible with ErrMalformedFormatOutput."},"source":{"file":"tmux/format.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatDecodeError.Unwrap","product":"core","slug":"tmux-formatdecodeerror-unwrap"},{"id":"tmux.FormatValues","name":"FormatValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"FormatValues is a read-only view of format expansions materialized with a Session, Window, Pane, or Client. Its methods do not query tmux. Projected cross-scope fields do not imply that the referenced record was materialized.","body":"Typed accessors return ok == false for an absent, empty, or malformed value;\n[FormatValues.Raw] distinguishes absent from present empty expansions. The\nzero value reports every field as absent."},"source":{"file":"tmux/format.go","line":97,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues","product":"core","slug":"tmux-formatvalues"},{"id":"tmux.FormatValues.Raw","name":"Raw","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(string, bool)"}],"doc":{"summary":"Raw returns the exact materialized tmux format expansion for name. It never queries tmux; ok distinguishes an absent field from a present empty value."},"source":{"file":"tmux/format.go","line":226,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.Raw","product":"core","slug":"tmux-formatvalues-raw"},{"id":"tmux.Session.Formats","name":"Formats","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"FormatValues"}],"doc":{"summary":"Formats returns this Session's read-only materialized tmux format values. It does not query tmux; use [Server.Snapshot] to obtain a fresh record."},"source":{"file":"tmux/format.go","line":232,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Formats","product":"core","slug":"tmux-session-formats"},{"id":"tmux.Window.Formats","name":"Formats","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"FormatValues"}],"doc":{"summary":"Formats returns this Window's read-only materialized tmux format values. It does not query tmux; use [Server.Snapshot] to obtain a fresh record."},"source":{"file":"tmux/format.go","line":238,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Formats","product":"core","slug":"tmux-window-formats"},{"id":"tmux.Pane.Formats","name":"Formats","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"FormatValues"}],"doc":{"summary":"Formats returns this Pane's read-only materialized tmux format values. It does not query tmux; use [Server.Snapshot] to obtain a fresh record."},"source":{"file":"tmux/format.go","line":244,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Formats","product":"core","slug":"tmux-pane-formats"},{"id":"tmux.Client.Formats","name":"Formats","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"FormatValues"}],"doc":{"summary":"Formats returns this Client's read-only materialized tmux format values. It does not query tmux; use [Server.Snapshot] to obtain a fresh record."},"source":{"file":"tmux/format.go","line":250,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Formats","product":"core","slug":"tmux-client-formats"},{"id":"tmux.FormatValues.ActiveWindowIndex","name":"ActiveWindowIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ActiveWindowIndex returns tmux #{active_window_index} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":223,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ActiveWindowIndex","product":"core","slug":"tmux-formatvalues-activewindowindex"},{"id":"tmux.FormatValues.AlternateOn","name":"AlternateOn","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AlternateOn returns tmux #{alternate_on} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":226,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.AlternateOn","product":"core","slug":"tmux-formatvalues-alternateon"},{"id":"tmux.FormatValues.AlternateSavedX","name":"AlternateSavedX","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"AlternateSavedX returns tmux #{alternate_saved_x} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":229,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.AlternateSavedX","product":"core","slug":"tmux-formatvalues-alternatesavedx"},{"id":"tmux.FormatValues.AlternateSavedY","name":"AlternateSavedY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"AlternateSavedY returns tmux #{alternate_saved_y} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":232,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.AlternateSavedY","product":"core","slug":"tmux-formatvalues-alternatesavedy"},{"id":"tmux.FormatValues.BracketPasteFlag","name":"BracketPasteFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"BracketPasteFlag returns tmux #{bracket_paste_flag} as bool from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":235,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.BracketPasteFlag","product":"core","slug":"tmux-formatvalues-bracketpasteflag"},{"id":"tmux.FormatValues.BufferModeFormat","name":"BufferModeFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"BufferModeFormat returns tmux #{buffer_mode_format} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":238,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.BufferModeFormat","product":"core","slug":"tmux-formatvalues-buffermodeformat"},{"id":"tmux.FormatValues.ClientActivity","name":"ClientActivity","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"ClientActivity returns tmux #{client_activity} as time.Time from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":243,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientActivity","product":"core","slug":"tmux-formatvalues-clientactivity"},{"id":"tmux.FormatValues.ClientCellHeight","name":"ClientCellHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientCellHeight returns tmux #{client_cell_height} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":246,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientCellHeight","product":"core","slug":"tmux-formatvalues-clientcellheight"},{"id":"tmux.FormatValues.ClientCellWidth","name":"ClientCellWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientCellWidth returns tmux #{client_cell_width} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":249,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientCellWidth","product":"core","slug":"tmux-formatvalues-clientcellwidth"},{"id":"tmux.FormatValues.ClientControlMode","name":"ClientControlMode","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ClientControlMode returns tmux #{client_control_mode} as bool from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":252,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientControlMode","product":"core","slug":"tmux-formatvalues-clientcontrolmode"},{"id":"tmux.FormatValues.ClientCreated","name":"ClientCreated","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"ClientCreated returns tmux #{client_created} as time.Time from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":257,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientCreated","product":"core","slug":"tmux-formatvalues-clientcreated"},{"id":"tmux.FormatValues.ClientDiscarded","name":"ClientDiscarded","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientDiscarded returns tmux #{client_discarded} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":260,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientDiscarded","product":"core","slug":"tmux-formatvalues-clientdiscarded"},{"id":"tmux.FormatValues.ClientFlags","name":"ClientFlags","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientFlags returns tmux #{client_flags} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":263,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientFlags","product":"core","slug":"tmux-formatvalues-clientflags"},{"id":"tmux.FormatValues.ClientHeight","name":"ClientHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientHeight returns tmux #{client_height} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":266,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientHeight","product":"core","slug":"tmux-formatvalues-clientheight"},{"id":"tmux.FormatValues.ClientKeyTable","name":"ClientKeyTable","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientKeyTable returns tmux #{client_key_table} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":269,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientKeyTable","product":"core","slug":"tmux-formatvalues-clientkeytable"},{"id":"tmux.FormatValues.ClientLastSession","name":"ClientLastSession","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientLastSession returns tmux #{client_last_session} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":272,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientLastSession","product":"core","slug":"tmux-formatvalues-clientlastsession"},{"id":"tmux.FormatValues.ClientModeFormat","name":"ClientModeFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientModeFormat returns tmux #{client_mode_format} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":277,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientModeFormat","product":"core","slug":"tmux-formatvalues-clientmodeformat"},{"id":"tmux.FormatValues.ClientName","name":"ClientName","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(ClientName, bool)"}],"doc":{"summary":"ClientName returns tmux #{client_name} as ClientName from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":282,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientName","product":"core","slug":"tmux-formatvalues-clientname"},{"id":"tmux.FormatValues.ClientPID","name":"ClientPID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientPID returns tmux #{client_pid} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":285,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientPID","product":"core","slug":"tmux-formatvalues-clientpid"},{"id":"tmux.FormatValues.ClientPrefix","name":"ClientPrefix","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ClientPrefix returns tmux #{client_prefix} as bool from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":288,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientPrefix","product":"core","slug":"tmux-formatvalues-clientprefix"},{"id":"tmux.FormatValues.ClientReadOnly","name":"ClientReadOnly","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ClientReadOnly returns tmux #{client_readonly} as bool from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":291,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientReadOnly","product":"core","slug":"tmux-formatvalues-clientreadonly"},{"id":"tmux.FormatValues.ClientSession","name":"ClientSession","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientSession returns tmux #{client_session} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":294,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientSession","product":"core","slug":"tmux-formatvalues-clientsession"},{"id":"tmux.FormatValues.ClientTermFeatures","name":"ClientTermFeatures","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientTermFeatures returns tmux #{client_termfeatures} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":297,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientTermFeatures","product":"core","slug":"tmux-formatvalues-clienttermfeatures"},{"id":"tmux.FormatValues.ClientTermName","name":"ClientTermName","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientTermName returns tmux #{client_termname} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":302,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientTermName","product":"core","slug":"tmux-formatvalues-clienttermname"},{"id":"tmux.FormatValues.ClientTermType","name":"ClientTermType","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientTermType returns tmux #{client_termtype} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":305,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientTermType","product":"core","slug":"tmux-formatvalues-clienttermtype"},{"id":"tmux.FormatValues.ClientTTY","name":"ClientTTY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientTTY returns tmux #{client_tty} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":308,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientTTY","product":"core","slug":"tmux-formatvalues-clienttty"},{"id":"tmux.FormatValues.ClientUID","name":"ClientUID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientUID returns tmux #{client_uid} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":311,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientUID","product":"core","slug":"tmux-formatvalues-clientuid"},{"id":"tmux.FormatValues.ClientUser","name":"ClientUser","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ClientUser returns tmux #{client_user} as string from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":314,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientUser","product":"core","slug":"tmux-formatvalues-clientuser"},{"id":"tmux.FormatValues.ClientUTF8","name":"ClientUTF8","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ClientUTF8 returns tmux #{client_utf8} as bool from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":317,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientUTF8","product":"core","slug":"tmux-formatvalues-clientutf8"},{"id":"tmux.FormatValues.ClientWidth","name":"ClientWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientWidth returns tmux #{client_width} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":320,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientWidth","product":"core","slug":"tmux-formatvalues-clientwidth"},{"id":"tmux.FormatValues.ClientWritten","name":"ClientWritten","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ClientWritten returns tmux #{client_written} as int from materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":323,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ClientWritten","product":"core","slug":"tmux-formatvalues-clientwritten"},{"id":"tmux.FormatValues.ConfigFiles","name":"ConfigFiles","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ConfigFiles returns tmux #{config_files} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":326,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ConfigFiles","product":"core","slug":"tmux-formatvalues-configfiles"},{"id":"tmux.FormatValues.CursorBlinking","name":"CursorBlinking","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorBlinking returns tmux #{cursor_blinking} as bool from materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":329,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.CursorBlinking","product":"core","slug":"tmux-formatvalues-cursorblinking"},{"id":"tmux.FormatValues.CursorCharacter","name":"CursorCharacter","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorCharacter returns tmux #{cursor_character} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":332,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.CursorCharacter","product":"core","slug":"tmux-formatvalues-cursorcharacter"},{"id":"tmux.FormatValues.CursorColour","name":"CursorColour","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorColour returns tmux #{cursor_colour} as string from materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":335,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.CursorColour","product":"core","slug":"tmux-formatvalues-cursorcolour"},{"id":"tmux.FormatValues.CursorFlag","name":"CursorFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorFlag returns tmux #{cursor_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":338,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.CursorFlag","product":"core","slug":"tmux-formatvalues-cursorflag"},{"id":"tmux.FormatValues.CursorShape","name":"CursorShape","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorShape returns tmux #{cursor_shape} as string from materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":341,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.CursorShape","product":"core","slug":"tmux-formatvalues-cursorshape"},{"id":"tmux.FormatValues.CursorVeryVisible","name":"CursorVeryVisible","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorVeryVisible returns tmux #{cursor_very_visible} as bool from materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":344,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.CursorVeryVisible","product":"core","slug":"tmux-formatvalues-cursorveryvisible"},{"id":"tmux.FormatValues.CursorX","name":"CursorX","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CursorX returns tmux #{cursor_x} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":349,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.CursorX","product":"core","slug":"tmux-formatvalues-cursorx"},{"id":"tmux.FormatValues.CursorY","name":"CursorY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CursorY returns tmux #{cursor_y} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":352,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.CursorY","product":"core","slug":"tmux-formatvalues-cursory"},{"id":"tmux.FormatValues.HistoryAdded","name":"HistoryAdded","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryAdded returns tmux #{history_added} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":355,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.HistoryAdded","product":"core","slug":"tmux-formatvalues-historyadded"},{"id":"tmux.FormatValues.HistoryAllBytes","name":"HistoryAllBytes","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"HistoryAllBytes returns tmux #{history_all_bytes} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":358,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.HistoryAllBytes","product":"core","slug":"tmux-formatvalues-historyallbytes"},{"id":"tmux.FormatValues.HistoryBytes","name":"HistoryBytes","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryBytes returns tmux #{history_bytes} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":363,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.HistoryBytes","product":"core","slug":"tmux-formatvalues-historybytes"},{"id":"tmux.FormatValues.HistoryCollected","name":"HistoryCollected","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryCollected returns tmux #{history_collected} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":366,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.HistoryCollected","product":"core","slug":"tmux-formatvalues-historycollected"},{"id":"tmux.FormatValues.HistoryGeneration","name":"HistoryGeneration","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryGeneration returns tmux #{history_generation} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":369,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.HistoryGeneration","product":"core","slug":"tmux-formatvalues-historygeneration"},{"id":"tmux.FormatValues.HistoryLimit","name":"HistoryLimit","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryLimit returns tmux #{history_limit} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":372,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.HistoryLimit","product":"core","slug":"tmux-formatvalues-historylimit"},{"id":"tmux.FormatValues.HistorySize","name":"HistorySize","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistorySize returns tmux #{history_size} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":375,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.HistorySize","product":"core","slug":"tmux-formatvalues-historysize"},{"id":"tmux.FormatValues.Host","name":"Host","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Host returns tmux #{host} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":378,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.Host","product":"core","slug":"tmux-formatvalues-host"},{"id":"tmux.FormatValues.HostShort","name":"HostShort","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"HostShort returns tmux #{host_short} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":381,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.HostShort","product":"core","slug":"tmux-formatvalues-hostshort"},{"id":"tmux.FormatValues.InsertFlag","name":"InsertFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"InsertFlag returns tmux #{insert_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":384,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.InsertFlag","product":"core","slug":"tmux-formatvalues-insertflag"},{"id":"tmux.FormatValues.KeypadCursorFlag","name":"KeypadCursorFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"KeypadCursorFlag returns tmux #{keypad_cursor_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":387,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.KeypadCursorFlag","product":"core","slug":"tmux-formatvalues-keypadcursorflag"},{"id":"tmux.FormatValues.KeypadFlag","name":"KeypadFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"KeypadFlag returns tmux #{keypad_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":390,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.KeypadFlag","product":"core","slug":"tmux-formatvalues-keypadflag"},{"id":"tmux.FormatValues.LastWindowIndex","name":"LastWindowIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"LastWindowIndex returns tmux #{last_window_index} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":393,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.LastWindowIndex","product":"core","slug":"tmux-formatvalues-lastwindowindex"},{"id":"tmux.FormatValues.Line","name":"Line","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Line returns tmux #{line} as int from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":396,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.Line","product":"core","slug":"tmux-formatvalues-line"},{"id":"tmux.FormatValues.MouseAllFlag","name":"MouseAllFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseAllFlag returns tmux #{mouse_all_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":399,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.MouseAllFlag","product":"core","slug":"tmux-formatvalues-mouseallflag"},{"id":"tmux.FormatValues.MouseAnyFlag","name":"MouseAnyFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseAnyFlag returns tmux #{mouse_any_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":402,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.MouseAnyFlag","product":"core","slug":"tmux-formatvalues-mouseanyflag"},{"id":"tmux.FormatValues.MouseButtonFlag","name":"MouseButtonFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseButtonFlag returns tmux #{mouse_button_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":405,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.MouseButtonFlag","product":"core","slug":"tmux-formatvalues-mousebuttonflag"},{"id":"tmux.FormatValues.MouseSGRFlag","name":"MouseSGRFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseSGRFlag returns tmux #{mouse_sgr_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":408,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.MouseSGRFlag","product":"core","slug":"tmux-formatvalues-mousesgrflag"},{"id":"tmux.FormatValues.MouseStandardFlag","name":"MouseStandardFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseStandardFlag returns tmux #{mouse_standard_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":411,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.MouseStandardFlag","product":"core","slug":"tmux-formatvalues-mousestandardflag"},{"id":"tmux.FormatValues.MouseUTF8Flag","name":"MouseUTF8Flag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseUTF8Flag returns tmux #{mouse_utf8_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":416,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.MouseUTF8Flag","product":"core","slug":"tmux-formatvalues-mouseutf8flag"},{"id":"tmux.FormatValues.NextSessionID","name":"NextSessionID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(SessionID, bool)"}],"doc":{"summary":"NextSessionID returns tmux #{next_session_id} as SessionID from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":419,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.NextSessionID","product":"core","slug":"tmux-formatvalues-nextsessionid"},{"id":"tmux.FormatValues.OriginFlag","name":"OriginFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"OriginFlag returns tmux #{origin_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":424,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.OriginFlag","product":"core","slug":"tmux-formatvalues-originflag"},{"id":"tmux.FormatValues.PaneActive","name":"PaneActive","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneActive returns tmux #{pane_active} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":427,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneActive","product":"core","slug":"tmux-formatvalues-paneactive"},{"id":"tmux.FormatValues.PaneAtBottom","name":"PaneAtBottom","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneAtBottom returns tmux #{pane_at_bottom} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":430,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneAtBottom","product":"core","slug":"tmux-formatvalues-paneatbottom"},{"id":"tmux.FormatValues.PaneAtLeft","name":"PaneAtLeft","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneAtLeft returns tmux #{pane_at_left} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":433,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneAtLeft","product":"core","slug":"tmux-formatvalues-paneatleft"},{"id":"tmux.FormatValues.PaneAtRight","name":"PaneAtRight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneAtRight returns tmux #{pane_at_right} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":436,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneAtRight","product":"core","slug":"tmux-formatvalues-paneatright"},{"id":"tmux.FormatValues.PaneAtTop","name":"PaneAtTop","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneAtTop returns tmux #{pane_at_top} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":439,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneAtTop","product":"core","slug":"tmux-formatvalues-paneattop"},{"id":"tmux.FormatValues.PaneBG","name":"PaneBG","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneBG returns tmux #{pane_bg} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":442,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneBG","product":"core","slug":"tmux-formatvalues-panebg"},{"id":"tmux.FormatValues.PaneBottom","name":"PaneBottom","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneBottom returns tmux #{pane_bottom} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":445,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneBottom","product":"core","slug":"tmux-formatvalues-panebottom"},{"id":"tmux.FormatValues.PaneCommandRunning","name":"PaneCommandRunning","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneCommandRunning returns tmux #{pane_command_running} as bool from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":448,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneCommandRunning","product":"core","slug":"tmux-formatvalues-panecommandrunning"},{"id":"tmux.FormatValues.PaneCurrentCommand","name":"PaneCurrentCommand","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneCurrentCommand returns tmux #{pane_current_command} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":453,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneCurrentCommand","product":"core","slug":"tmux-formatvalues-panecurrentcommand"},{"id":"tmux.FormatValues.PaneCurrentPath","name":"PaneCurrentPath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneCurrentPath returns tmux #{pane_current_path} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":458,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneCurrentPath","product":"core","slug":"tmux-formatvalues-panecurrentpath"},{"id":"tmux.FormatValues.PaneDead","name":"PaneDead","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneDead returns tmux #{pane_dead} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":463,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneDead","product":"core","slug":"tmux-formatvalues-panedead"},{"id":"tmux.FormatValues.PaneDeadSignal","name":"PaneDeadSignal","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneDeadSignal returns tmux #{pane_dead_signal} as string from materialized pane-scoped fields (tmux 3.3 or later)."},"source":{"file":"tmux/format_generated.go","line":466,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneDeadSignal","product":"core","slug":"tmux-formatvalues-panedeadsignal"},{"id":"tmux.FormatValues.PaneDeadStatus","name":"PaneDeadStatus","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneDeadStatus returns tmux #{pane_dead_status} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":469,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneDeadStatus","product":"core","slug":"tmux-formatvalues-panedeadstatus"},{"id":"tmux.FormatValues.PaneDeadTime","name":"PaneDeadTime","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"PaneDeadTime returns tmux #{pane_dead_time} as time.Time from materialized pane-scoped fields (tmux 3.3 or later)."},"source":{"file":"tmux/format_generated.go","line":472,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneDeadTime","product":"core","slug":"tmux-formatvalues-panedeadtime"},{"id":"tmux.FormatValues.PaneFG","name":"PaneFG","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneFG returns tmux #{pane_fg} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":475,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneFG","product":"core","slug":"tmux-formatvalues-panefg"},{"id":"tmux.FormatValues.PaneFlags","name":"PaneFlags","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneFlags returns tmux #{pane_flags} as string from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":478,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneFlags","product":"core","slug":"tmux-formatvalues-paneflags"},{"id":"tmux.FormatValues.PaneFloatingFlag","name":"PaneFloatingFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneFloatingFlag returns tmux #{pane_floating_flag} as bool from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":481,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneFloatingFlag","product":"core","slug":"tmux-formatvalues-panefloatingflag"},{"id":"tmux.FormatValues.PaneFormat","name":"PaneFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneFormat returns tmux #{pane_format} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":484,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneFormat","product":"core","slug":"tmux-formatvalues-paneformat"},{"id":"tmux.FormatValues.PaneHeight","name":"PaneHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneHeight returns tmux #{pane_height} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":487,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneHeight","product":"core","slug":"tmux-formatvalues-paneheight"},{"id":"tmux.FormatValues.PaneID","name":"PaneID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(PaneID, bool)"}],"doc":{"summary":"PaneID returns tmux #{pane_id} as PaneID from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":490,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneID","product":"core","slug":"tmux-formatvalues-paneid"},{"id":"tmux.FormatValues.PaneInMode","name":"PaneInMode","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneInMode returns tmux #{pane_in_mode} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":493,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneInMode","product":"core","slug":"tmux-formatvalues-paneinmode"},{"id":"tmux.FormatValues.PaneIndex","name":"PaneIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneIndex returns tmux #{pane_index} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":496,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneIndex","product":"core","slug":"tmux-formatvalues-paneindex"},{"id":"tmux.FormatValues.PaneInputOff","name":"PaneInputOff","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneInputOff returns tmux #{pane_input_off} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":499,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneInputOff","product":"core","slug":"tmux-formatvalues-paneinputoff"},{"id":"tmux.FormatValues.PaneKeyMode","name":"PaneKeyMode","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneKeyMode returns tmux #{pane_key_mode} as string from materialized pane-scoped fields (tmux 3.5 or later)."},"source":{"file":"tmux/format_generated.go","line":502,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneKeyMode","product":"core","slug":"tmux-formatvalues-panekeymode"},{"id":"tmux.FormatValues.PaneLast","name":"PaneLast","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneLast returns tmux #{pane_last} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":505,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneLast","product":"core","slug":"tmux-formatvalues-panelast"},{"id":"tmux.FormatValues.PaneLeft","name":"PaneLeft","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneLeft returns tmux #{pane_left} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":508,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneLeft","product":"core","slug":"tmux-formatvalues-paneleft"},{"id":"tmux.FormatValues.PaneMarked","name":"PaneMarked","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneMarked returns tmux #{pane_marked} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":511,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneMarked","product":"core","slug":"tmux-formatvalues-panemarked"},{"id":"tmux.FormatValues.PaneMarkedSet","name":"PaneMarkedSet","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneMarkedSet returns tmux #{pane_marked_set} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":514,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneMarkedSet","product":"core","slug":"tmux-formatvalues-panemarkedset"},{"id":"tmux.FormatValues.PaneModalFlag","name":"PaneModalFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneModalFlag returns tmux #{pane_modal_flag} as bool from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":517,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneModalFlag","product":"core","slug":"tmux-formatvalues-panemodalflag"},{"id":"tmux.FormatValues.PaneMode","name":"PaneMode","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneMode returns tmux #{pane_mode} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":520,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneMode","product":"core","slug":"tmux-formatvalues-panemode"},{"id":"tmux.FormatValues.PaneOutputGeneration","name":"PaneOutputGeneration","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneOutputGeneration returns tmux #{pane_output_generation} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":523,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneOutputGeneration","product":"core","slug":"tmux-formatvalues-paneoutputgeneration"},{"id":"tmux.FormatValues.PanePath","name":"PanePath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PanePath returns tmux #{pane_path} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":528,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PanePath","product":"core","slug":"tmux-formatvalues-panepath"},{"id":"tmux.FormatValues.PanePBProgress","name":"PanePBProgress","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PanePBProgress returns tmux #{pane_pb_progress} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":531,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PanePBProgress","product":"core","slug":"tmux-formatvalues-panepbprogress"},{"id":"tmux.FormatValues.PanePBState","name":"PanePBState","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PanePBState returns tmux #{pane_pb_state} as string from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":534,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PanePBState","product":"core","slug":"tmux-formatvalues-panepbstate"},{"id":"tmux.FormatValues.PanePID","name":"PanePID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PanePID returns tmux #{pane_pid} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":537,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PanePID","product":"core","slug":"tmux-formatvalues-panepid"},{"id":"tmux.FormatValues.PanePipe","name":"PanePipe","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PanePipe returns tmux #{pane_pipe} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":540,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PanePipe","product":"core","slug":"tmux-formatvalues-panepipe"},{"id":"tmux.FormatValues.PanePipePID","name":"PanePipePID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PanePipePID returns tmux #{pane_pipe_pid} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":543,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PanePipePID","product":"core","slug":"tmux-formatvalues-panepipepid"},{"id":"tmux.FormatValues.PanePrivateModes","name":"PanePrivateModes","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PanePrivateModes returns tmux #{pane_private_modes} as string from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":546,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PanePrivateModes","product":"core","slug":"tmux-formatvalues-paneprivatemodes"},{"id":"tmux.FormatValues.PaneRight","name":"PaneRight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneRight returns tmux #{pane_right} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":551,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneRight","product":"core","slug":"tmux-formatvalues-paneright"},{"id":"tmux.FormatValues.PaneSearchString","name":"PaneSearchString","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneSearchString returns tmux #{pane_search_string} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":554,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneSearchString","product":"core","slug":"tmux-formatvalues-panesearchstring"},{"id":"tmux.FormatValues.PaneStartCommand","name":"PaneStartCommand","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneStartCommand returns tmux #{pane_start_command} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":559,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneStartCommand","product":"core","slug":"tmux-formatvalues-panestartcommand"},{"id":"tmux.FormatValues.PaneStartCommandList","name":"PaneStartCommandList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneStartCommandList returns tmux #{pane_start_command_list} as string from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":564,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneStartCommandList","product":"core","slug":"tmux-formatvalues-panestartcommandlist"},{"id":"tmux.FormatValues.PaneStartPath","name":"PaneStartPath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneStartPath returns tmux #{pane_start_path} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":569,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneStartPath","product":"core","slug":"tmux-formatvalues-panestartpath"},{"id":"tmux.FormatValues.PaneSynchronized","name":"PaneSynchronized","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneSynchronized returns tmux #{pane_synchronized} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":572,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneSynchronized","product":"core","slug":"tmux-formatvalues-panesynchronized"},{"id":"tmux.FormatValues.PaneTabs","name":"PaneTabs","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneTabs returns tmux #{pane_tabs} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":575,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneTabs","product":"core","slug":"tmux-formatvalues-panetabs"},{"id":"tmux.FormatValues.PaneTitle","name":"PaneTitle","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneTitle returns tmux #{pane_title} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":578,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneTitle","product":"core","slug":"tmux-formatvalues-panetitle"},{"id":"tmux.FormatValues.PaneTop","name":"PaneTop","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneTop returns tmux #{pane_top} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":581,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneTop","product":"core","slug":"tmux-formatvalues-panetop"},{"id":"tmux.FormatValues.PaneTTY","name":"PaneTTY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PaneTTY returns tmux #{pane_tty} as string from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":584,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneTTY","product":"core","slug":"tmux-formatvalues-panetty"},{"id":"tmux.FormatValues.PaneUnseenChanges","name":"PaneUnseenChanges","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneUnseenChanges returns tmux #{pane_unseen_changes} as bool from materialized pane-scoped fields (tmux 3.4 or later)."},"source":{"file":"tmux/format_generated.go","line":587,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneUnseenChanges","product":"core","slug":"tmux-formatvalues-paneunseenchanges"},{"id":"tmux.FormatValues.PaneUnzoomedHeight","name":"PaneUnzoomedHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneUnzoomedHeight returns tmux #{pane_unzoomed_height} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":592,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneUnzoomedHeight","product":"core","slug":"tmux-formatvalues-paneunzoomedheight"},{"id":"tmux.FormatValues.PaneUnzoomedWidth","name":"PaneUnzoomedWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneUnzoomedWidth returns tmux #{pane_unzoomed_width} as int from materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":597,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneUnzoomedWidth","product":"core","slug":"tmux-formatvalues-paneunzoomedwidth"},{"id":"tmux.FormatValues.PaneWidth","name":"PaneWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneWidth returns tmux #{pane_width} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":600,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneWidth","product":"core","slug":"tmux-formatvalues-panewidth"},{"id":"tmux.FormatValues.PaneX","name":"PaneX","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneX returns tmux #{pane_x} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":603,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneX","product":"core","slug":"tmux-formatvalues-panex"},{"id":"tmux.FormatValues.PaneY","name":"PaneY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneY returns tmux #{pane_y} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":606,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneY","product":"core","slug":"tmux-formatvalues-paney"},{"id":"tmux.FormatValues.PaneZ","name":"PaneZ","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneZ returns tmux #{pane_z} as int from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":609,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneZ","product":"core","slug":"tmux-formatvalues-panez"},{"id":"tmux.FormatValues.PaneZoomedFlag","name":"PaneZoomedFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"PaneZoomedFlag returns tmux #{pane_zoomed_flag} as bool from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":612,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PaneZoomedFlag","product":"core","slug":"tmux-formatvalues-panezoomedflag"},{"id":"tmux.FormatValues.PID","name":"PID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PID returns tmux #{pid} as int from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":615,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.PID","product":"core","slug":"tmux-formatvalues-pid"},{"id":"tmux.FormatValues.ScrollRegionLower","name":"ScrollRegionLower","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ScrollRegionLower returns tmux #{scroll_region_lower} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":618,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ScrollRegionLower","product":"core","slug":"tmux-formatvalues-scrollregionlower"},{"id":"tmux.FormatValues.ScrollRegionUpper","name":"ScrollRegionUpper","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ScrollRegionUpper returns tmux #{scroll_region_upper} as int from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":621,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ScrollRegionUpper","product":"core","slug":"tmux-formatvalues-scrollregionupper"},{"id":"tmux.FormatValues.ServerSessions","name":"ServerSessions","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ServerSessions returns tmux #{server_sessions} as int from materialized universal-scoped fields (tmux 3.4 or later)."},"source":{"file":"tmux/format_generated.go","line":624,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.ServerSessions","product":"core","slug":"tmux-formatvalues-serversessions"},{"id":"tmux.FormatValues.SessionActive","name":"SessionActive","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionActive returns tmux #{session_active} as bool from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":627,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionActive","product":"core","slug":"tmux-formatvalues-sessionactive"},{"id":"tmux.FormatValues.SessionActivity","name":"SessionActivity","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"SessionActivity returns tmux #{session_activity} as time.Time from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":630,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionActivity","product":"core","slug":"tmux-formatvalues-sessionactivity"},{"id":"tmux.FormatValues.SessionActivityFlag","name":"SessionActivityFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionActivityFlag returns tmux #{session_activity_flag} as bool from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":635,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionActivityFlag","product":"core","slug":"tmux-formatvalues-sessionactivityflag"},{"id":"tmux.FormatValues.SessionAlert","name":"SessionAlert","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionAlert returns tmux #{session_alert} as string from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":640,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionAlert","product":"core","slug":"tmux-formatvalues-sessionalert"},{"id":"tmux.FormatValues.SessionAlerts","name":"SessionAlerts","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionAlerts returns tmux #{session_alerts} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":643,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionAlerts","product":"core","slug":"tmux-formatvalues-sessionalerts"},{"id":"tmux.FormatValues.SessionAttached","name":"SessionAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"SessionAttached returns tmux #{session_attached} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":646,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionAttached","product":"core","slug":"tmux-formatvalues-sessionattached"},{"id":"tmux.FormatValues.SessionAttachedList","name":"SessionAttachedList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionAttachedList returns tmux #{session_attached_list} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":649,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionAttachedList","product":"core","slug":"tmux-formatvalues-sessionattachedlist"},{"id":"tmux.FormatValues.SessionBellFlag","name":"SessionBellFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionBellFlag returns tmux #{session_bell_flag} as bool from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":654,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionBellFlag","product":"core","slug":"tmux-formatvalues-sessionbellflag"},{"id":"tmux.FormatValues.SessionCreated","name":"SessionCreated","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"SessionCreated returns tmux #{session_created} as time.Time from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":657,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionCreated","product":"core","slug":"tmux-formatvalues-sessioncreated"},{"id":"tmux.FormatValues.SessionFormat","name":"SessionFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionFormat returns tmux #{session_format} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":660,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionFormat","product":"core","slug":"tmux-formatvalues-sessionformat"},{"id":"tmux.FormatValues.SessionGroup","name":"SessionGroup","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionGroup returns tmux #{session_group} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":663,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionGroup","product":"core","slug":"tmux-formatvalues-sessiongroup"},{"id":"tmux.FormatValues.SessionGroupAttached","name":"SessionGroupAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"SessionGroupAttached returns tmux #{session_group_attached} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":666,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionGroupAttached","product":"core","slug":"tmux-formatvalues-sessiongroupattached"},{"id":"tmux.FormatValues.SessionGroupAttachedList","name":"SessionGroupAttachedList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionGroupAttachedList returns tmux #{session_group_attached_list} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":671,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionGroupAttachedList","product":"core","slug":"tmux-formatvalues-sessiongroupattachedlist"},{"id":"tmux.FormatValues.SessionGroupList","name":"SessionGroupList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionGroupList returns tmux #{session_group_list} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":676,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionGroupList","product":"core","slug":"tmux-formatvalues-sessiongrouplist"},{"id":"tmux.FormatValues.SessionGroupManyAttached","name":"SessionGroupManyAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionGroupManyAttached returns tmux #{session_group_many_attached} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":681,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionGroupManyAttached","product":"core","slug":"tmux-formatvalues-sessiongroupmanyattached"},{"id":"tmux.FormatValues.SessionGroupSize","name":"SessionGroupSize","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"SessionGroupSize returns tmux #{session_group_size} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":686,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionGroupSize","product":"core","slug":"tmux-formatvalues-sessiongroupsize"},{"id":"tmux.FormatValues.SessionGrouped","name":"SessionGrouped","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionGrouped returns tmux #{session_grouped} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":689,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionGrouped","product":"core","slug":"tmux-formatvalues-sessiongrouped"},{"id":"tmux.FormatValues.SessionID","name":"SessionID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(SessionID, bool)"}],"doc":{"summary":"SessionID returns tmux #{session_id} as SessionID from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":692,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionID","product":"core","slug":"tmux-formatvalues-sessionid"},{"id":"tmux.FormatValues.SessionLastAttached","name":"SessionLastAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"SessionLastAttached returns tmux #{session_last_attached} as time.Time from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":695,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionLastAttached","product":"core","slug":"tmux-formatvalues-sessionlastattached"},{"id":"tmux.FormatValues.SessionManyAttached","name":"SessionManyAttached","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionManyAttached returns tmux #{session_many_attached} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":700,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionManyAttached","product":"core","slug":"tmux-formatvalues-sessionmanyattached"},{"id":"tmux.FormatValues.SessionMarked","name":"SessionMarked","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionMarked returns tmux #{session_marked} as bool from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":705,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionMarked","product":"core","slug":"tmux-formatvalues-sessionmarked"},{"id":"tmux.FormatValues.SessionName","name":"SessionName","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionName returns tmux #{session_name} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":708,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionName","product":"core","slug":"tmux-formatvalues-sessionname"},{"id":"tmux.FormatValues.SessionPath","name":"SessionPath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionPath returns tmux #{session_path} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":711,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionPath","product":"core","slug":"tmux-formatvalues-sessionpath"},{"id":"tmux.FormatValues.SessionSilenceFlag","name":"SessionSilenceFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SessionSilenceFlag returns tmux #{session_silence_flag} as bool from materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":714,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionSilenceFlag","product":"core","slug":"tmux-formatvalues-sessionsilenceflag"},{"id":"tmux.FormatValues.SessionStack","name":"SessionStack","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SessionStack returns tmux #{session_stack} as string from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":719,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionStack","product":"core","slug":"tmux-formatvalues-sessionstack"},{"id":"tmux.FormatValues.SessionWindows","name":"SessionWindows","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"SessionWindows returns tmux #{session_windows} as int from materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":722,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SessionWindows","product":"core","slug":"tmux-formatvalues-sessionwindows"},{"id":"tmux.FormatValues.SixelSupport","name":"SixelSupport","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SixelSupport returns tmux #{sixel_support} as bool from materialized universal-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":725,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SixelSupport","product":"core","slug":"tmux-formatvalues-sixelsupport"},{"id":"tmux.FormatValues.SocketPath","name":"SocketPath","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SocketPath returns tmux #{socket_path} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":728,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SocketPath","product":"core","slug":"tmux-formatvalues-socketpath"},{"id":"tmux.FormatValues.StartTime","name":"StartTime","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"StartTime returns tmux #{start_time} as time.Time from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":731,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.StartTime","product":"core","slug":"tmux-formatvalues-starttime"},{"id":"tmux.FormatValues.SynchronizedOutputFlag","name":"SynchronizedOutputFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SynchronizedOutputFlag returns tmux #{synchronized_output_flag} as bool from materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":734,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.SynchronizedOutputFlag","product":"core","slug":"tmux-formatvalues-synchronizedoutputflag"},{"id":"tmux.FormatValues.TreeModeFormat","name":"TreeModeFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TreeModeFormat returns tmux #{tree_mode_format} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":739,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.TreeModeFormat","product":"core","slug":"tmux-formatvalues-treemodeformat"},{"id":"tmux.FormatValues.UID","name":"UID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"UID returns tmux #{uid} as int from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":742,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.UID","product":"core","slug":"tmux-formatvalues-uid"},{"id":"tmux.FormatValues.User","name":"User","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"User returns tmux #{user} as string from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":745,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.User","product":"core","slug":"tmux-formatvalues-user"},{"id":"tmux.FormatValues.Version","name":"Version","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(Version, bool)"}],"doc":{"summary":"Version returns tmux #{version} as Version from materialized universal-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":748,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.Version","product":"core","slug":"tmux-formatvalues-version"},{"id":"tmux.FormatValues.WindowActive","name":"WindowActive","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowActive returns tmux #{window_active} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":751,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowActive","product":"core","slug":"tmux-formatvalues-windowactive"},{"id":"tmux.FormatValues.WindowActiveClients","name":"WindowActiveClients","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowActiveClients returns tmux #{window_active_clients} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":754,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowActiveClients","product":"core","slug":"tmux-formatvalues-windowactiveclients"},{"id":"tmux.FormatValues.WindowActiveClientsList","name":"WindowActiveClientsList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowActiveClientsList returns tmux #{window_active_clients_list} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":759,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowActiveClientsList","product":"core","slug":"tmux-formatvalues-windowactiveclientslist"},{"id":"tmux.FormatValues.WindowActiveSessions","name":"WindowActiveSessions","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowActiveSessions returns tmux #{window_active_sessions} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":764,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowActiveSessions","product":"core","slug":"tmux-formatvalues-windowactivesessions"},{"id":"tmux.FormatValues.WindowActiveSessionsList","name":"WindowActiveSessionsList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowActiveSessionsList returns tmux #{window_active_sessions_list} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":769,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowActiveSessionsList","product":"core","slug":"tmux-formatvalues-windowactivesessionslist"},{"id":"tmux.FormatValues.WindowActivity","name":"WindowActivity","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"WindowActivity returns tmux #{window_activity} as time.Time from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":774,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowActivity","product":"core","slug":"tmux-formatvalues-windowactivity"},{"id":"tmux.FormatValues.WindowActivityFlag","name":"WindowActivityFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowActivityFlag returns tmux #{window_activity_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":777,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowActivityFlag","product":"core","slug":"tmux-formatvalues-windowactivityflag"},{"id":"tmux.FormatValues.WindowBellFlag","name":"WindowBellFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowBellFlag returns tmux #{window_bell_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":782,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowBellFlag","product":"core","slug":"tmux-formatvalues-windowbellflag"},{"id":"tmux.FormatValues.WindowBigger","name":"WindowBigger","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowBigger returns tmux #{window_bigger} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":785,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowBigger","product":"core","slug":"tmux-formatvalues-windowbigger"},{"id":"tmux.FormatValues.WindowCellHeight","name":"WindowCellHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowCellHeight returns tmux #{window_cell_height} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":788,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowCellHeight","product":"core","slug":"tmux-formatvalues-windowcellheight"},{"id":"tmux.FormatValues.WindowCellWidth","name":"WindowCellWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowCellWidth returns tmux #{window_cell_width} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":791,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowCellWidth","product":"core","slug":"tmux-formatvalues-windowcellwidth"},{"id":"tmux.FormatValues.WindowEndFlag","name":"WindowEndFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowEndFlag returns tmux #{window_end_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":794,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowEndFlag","product":"core","slug":"tmux-formatvalues-windowendflag"},{"id":"tmux.FormatValues.WindowFlags","name":"WindowFlags","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowFlags returns tmux #{window_flags} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":797,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowFlags","product":"core","slug":"tmux-formatvalues-windowflags"},{"id":"tmux.FormatValues.WindowFormat","name":"WindowFormat","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowFormat returns tmux #{window_format} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":800,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowFormat","product":"core","slug":"tmux-formatvalues-windowformat"},{"id":"tmux.FormatValues.WindowHeight","name":"WindowHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowHeight returns tmux #{window_height} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":803,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowHeight","product":"core","slug":"tmux-formatvalues-windowheight"},{"id":"tmux.FormatValues.WindowID","name":"WindowID","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(WindowID, bool)"}],"doc":{"summary":"WindowID returns tmux #{window_id} as WindowID from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":806,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowID","product":"core","slug":"tmux-formatvalues-windowid"},{"id":"tmux.FormatValues.WindowIndex","name":"WindowIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowIndex returns tmux #{window_index} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":809,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowIndex","product":"core","slug":"tmux-formatvalues-windowindex"},{"id":"tmux.FormatValues.WindowLastFlag","name":"WindowLastFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowLastFlag returns tmux #{window_last_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":812,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowLastFlag","product":"core","slug":"tmux-formatvalues-windowlastflag"},{"id":"tmux.FormatValues.WindowLayout","name":"WindowLayout","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowLayout returns tmux #{window_layout} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":815,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowLayout","product":"core","slug":"tmux-formatvalues-windowlayout"},{"id":"tmux.FormatValues.WindowLinked","name":"WindowLinked","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowLinked returns tmux #{window_linked} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":818,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowLinked","product":"core","slug":"tmux-formatvalues-windowlinked"},{"id":"tmux.FormatValues.WindowLinkedSessions","name":"WindowLinkedSessions","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowLinkedSessions returns tmux #{window_linked_sessions} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":821,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowLinkedSessions","product":"core","slug":"tmux-formatvalues-windowlinkedsessions"},{"id":"tmux.FormatValues.WindowLinkedSessionsList","name":"WindowLinkedSessionsList","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowLinkedSessionsList returns tmux #{window_linked_sessions_list} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":826,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowLinkedSessionsList","product":"core","slug":"tmux-formatvalues-windowlinkedsessionslist"},{"id":"tmux.FormatValues.WindowManualHeight","name":"WindowManualHeight","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowManualHeight returns tmux #{window_manual_height} as int from materialized window-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":831,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowManualHeight","product":"core","slug":"tmux-formatvalues-windowmanualheight"},{"id":"tmux.FormatValues.WindowManualWidth","name":"WindowManualWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowManualWidth returns tmux #{window_manual_width} as int from materialized window-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":836,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowManualWidth","product":"core","slug":"tmux-formatvalues-windowmanualwidth"},{"id":"tmux.FormatValues.WindowMarkedFlag","name":"WindowMarkedFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowMarkedFlag returns tmux #{window_marked_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":839,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowMarkedFlag","product":"core","slug":"tmux-formatvalues-windowmarkedflag"},{"id":"tmux.FormatValues.WindowName","name":"WindowName","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowName returns tmux #{window_name} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":842,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowName","product":"core","slug":"tmux-formatvalues-windowname"},{"id":"tmux.FormatValues.WindowOffsetX","name":"WindowOffsetX","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowOffsetX returns tmux #{window_offset_x} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":845,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowOffsetX","product":"core","slug":"tmux-formatvalues-windowoffsetx"},{"id":"tmux.FormatValues.WindowOffsetY","name":"WindowOffsetY","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowOffsetY returns tmux #{window_offset_y} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":848,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowOffsetY","product":"core","slug":"tmux-formatvalues-windowoffsety"},{"id":"tmux.FormatValues.WindowPanes","name":"WindowPanes","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowPanes returns tmux #{window_panes} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":851,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowPanes","product":"core","slug":"tmux-formatvalues-windowpanes"},{"id":"tmux.FormatValues.WindowRawFlags","name":"WindowRawFlags","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowRawFlags returns tmux #{window_raw_flags} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":854,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowRawFlags","product":"core","slug":"tmux-formatvalues-windowrawflags"},{"id":"tmux.FormatValues.WindowSilenceFlag","name":"WindowSilenceFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowSilenceFlag returns tmux #{window_silence_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":857,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowSilenceFlag","product":"core","slug":"tmux-formatvalues-windowsilenceflag"},{"id":"tmux.FormatValues.WindowStackIndex","name":"WindowStackIndex","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowStackIndex returns tmux #{window_stack_index} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":862,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowStackIndex","product":"core","slug":"tmux-formatvalues-windowstackindex"},{"id":"tmux.FormatValues.WindowStartFlag","name":"WindowStartFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowStartFlag returns tmux #{window_start_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":865,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowStartFlag","product":"core","slug":"tmux-formatvalues-windowstartflag"},{"id":"tmux.FormatValues.WindowVisibleLayout","name":"WindowVisibleLayout","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"WindowVisibleLayout returns tmux #{window_visible_layout} as string from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":868,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowVisibleLayout","product":"core","slug":"tmux-formatvalues-windowvisiblelayout"},{"id":"tmux.FormatValues.WindowWidth","name":"WindowWidth","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowWidth returns tmux #{window_width} as int from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":873,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowWidth","product":"core","slug":"tmux-formatvalues-windowwidth"},{"id":"tmux.FormatValues.WindowZoomedFlag","name":"WindowZoomedFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WindowZoomedFlag returns tmux #{window_zoomed_flag} as bool from materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":876,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WindowZoomedFlag","product":"core","slug":"tmux-formatvalues-windowzoomedflag"},{"id":"tmux.FormatValues.WrapFlag","name":"WrapFlag","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WrapFlag returns tmux #{wrap_flag} as bool from materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":879,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.WrapFlag","product":"core","slug":"tmux-formatvalues-wrapflag"},{"id":"tmux.Session.ActiveWindowIndex","name":"ActiveWindowIndex","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ActiveWindowIndex returns tmux #{active_window_index} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":882,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ActiveWindowIndex","product":"core","slug":"tmux-session-activewindowindex"},{"id":"tmux.Session.LastWindowIndex","name":"LastWindowIndex","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"LastWindowIndex returns tmux #{last_window_index} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":885,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.LastWindowIndex","product":"core","slug":"tmux-session-lastwindowindex"},{"id":"tmux.Session.Active","name":"Active","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Active returns tmux #{session_active} as bool from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":888,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Active","product":"core","slug":"tmux-session-active"},{"id":"tmux.Session.Activity","name":"Activity","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Activity returns tmux #{session_activity} as time.Time from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":891,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Activity","product":"core","slug":"tmux-session-activity"},{"id":"tmux.Session.ActivityFlag","name":"ActivityFlag","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ActivityFlag returns tmux #{session_activity_flag} as bool from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":894,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ActivityFlag","product":"core","slug":"tmux-session-activityflag"},{"id":"tmux.Session.Alert","name":"Alert","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Alert returns tmux #{session_alert} as string from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":897,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Alert","product":"core","slug":"tmux-session-alert"},{"id":"tmux.Session.Alerts","name":"Alerts","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Alerts returns tmux #{session_alerts} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":900,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Alerts","product":"core","slug":"tmux-session-alerts"},{"id":"tmux.Session.Attached","name":"Attached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Attached returns tmux #{session_attached} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":903,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Attached","product":"core","slug":"tmux-session-attached"},{"id":"tmux.Session.AttachedList","name":"AttachedList","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"AttachedList returns tmux #{session_attached_list} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":906,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.AttachedList","product":"core","slug":"tmux-session-attachedlist"},{"id":"tmux.Session.BellFlag","name":"BellFlag","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"BellFlag returns tmux #{session_bell_flag} as bool from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":909,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.BellFlag","product":"core","slug":"tmux-session-bellflag"},{"id":"tmux.Session.Created","name":"Created","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Created returns tmux #{session_created} as time.Time from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":912,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Created","product":"core","slug":"tmux-session-created"},{"id":"tmux.Session.Format","name":"Format","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Format returns tmux #{session_format} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":915,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Format","product":"core","slug":"tmux-session-format"},{"id":"tmux.Session.Group","name":"Group","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Group returns tmux #{session_group} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":918,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Group","product":"core","slug":"tmux-session-group"},{"id":"tmux.Session.GroupAttached","name":"GroupAttached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"GroupAttached returns tmux #{session_group_attached} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":921,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.GroupAttached","product":"core","slug":"tmux-session-groupattached"},{"id":"tmux.Session.GroupAttachedList","name":"GroupAttachedList","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"GroupAttachedList returns tmux #{session_group_attached_list} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":924,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.GroupAttachedList","product":"core","slug":"tmux-session-groupattachedlist"},{"id":"tmux.Session.GroupList","name":"GroupList","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"GroupList returns tmux #{session_group_list} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":929,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.GroupList","product":"core","slug":"tmux-session-grouplist"},{"id":"tmux.Session.GroupManyAttached","name":"GroupManyAttached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"GroupManyAttached returns tmux #{session_group_many_attached} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":932,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.GroupManyAttached","product":"core","slug":"tmux-session-groupmanyattached"},{"id":"tmux.Session.GroupSize","name":"GroupSize","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"GroupSize returns tmux #{session_group_size} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":937,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.GroupSize","product":"core","slug":"tmux-session-groupsize"},{"id":"tmux.Session.Grouped","name":"Grouped","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Grouped returns tmux #{session_grouped} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":940,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Grouped","product":"core","slug":"tmux-session-grouped"},{"id":"tmux.Session.LastAttached","name":"LastAttached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"LastAttached returns tmux #{session_last_attached} as time.Time from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":943,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.LastAttached","product":"core","slug":"tmux-session-lastattached"},{"id":"tmux.Session.ManyAttached","name":"ManyAttached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ManyAttached returns tmux #{session_many_attached} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":946,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ManyAttached","product":"core","slug":"tmux-session-manyattached"},{"id":"tmux.Session.Marked","name":"Marked","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Marked returns tmux #{session_marked} as bool from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":949,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Marked","product":"core","slug":"tmux-session-marked"},{"id":"tmux.Session.Name","name":"Name","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Name returns tmux #{session_name} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":952,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Name","product":"core","slug":"tmux-session-name"},{"id":"tmux.Session.Path","name":"Path","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Path returns tmux #{session_path} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":955,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Path","product":"core","slug":"tmux-session-path"},{"id":"tmux.Session.SilenceFlag","name":"SilenceFlag","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SilenceFlag returns tmux #{session_silence_flag} as bool from this Session's materialized session-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":958,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SilenceFlag","product":"core","slug":"tmux-session-silenceflag"},{"id":"tmux.Session.Stack","name":"Stack","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Stack returns tmux #{session_stack} as string from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":961,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Stack","product":"core","slug":"tmux-session-stack"},{"id":"tmux.Session.WindowCount","name":"WindowCount","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"WindowCount returns tmux #{session_windows} as int from this Session's materialized session-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":964,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.WindowCount","product":"core","slug":"tmux-session-windowcount"},{"id":"tmux.Window.Active","name":"Active","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Active returns tmux #{window_active} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":967,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Active","product":"core","slug":"tmux-window-active"},{"id":"tmux.Window.ActiveClients","name":"ActiveClients","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ActiveClients returns tmux #{window_active_clients} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":970,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ActiveClients","product":"core","slug":"tmux-window-activeclients"},{"id":"tmux.Window.ActiveClientsList","name":"ActiveClientsList","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ActiveClientsList returns tmux #{window_active_clients_list} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":973,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ActiveClientsList","product":"core","slug":"tmux-window-activeclientslist"},{"id":"tmux.Window.ActiveSessions","name":"ActiveSessions","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ActiveSessions returns tmux #{window_active_sessions} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":978,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ActiveSessions","product":"core","slug":"tmux-window-activesessions"},{"id":"tmux.Window.ActiveSessionsList","name":"ActiveSessionsList","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ActiveSessionsList returns tmux #{window_active_sessions_list} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":981,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ActiveSessionsList","product":"core","slug":"tmux-window-activesessionslist"},{"id":"tmux.Window.Activity","name":"Activity","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Activity returns tmux #{window_activity} as time.Time from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":986,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Activity","product":"core","slug":"tmux-window-activity"},{"id":"tmux.Window.ActivityFlag","name":"ActivityFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ActivityFlag returns tmux #{window_activity_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":989,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ActivityFlag","product":"core","slug":"tmux-window-activityflag"},{"id":"tmux.Window.BellFlag","name":"BellFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"BellFlag returns tmux #{window_bell_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":992,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.BellFlag","product":"core","slug":"tmux-window-bellflag"},{"id":"tmux.Window.Bigger","name":"Bigger","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Bigger returns tmux #{window_bigger} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":995,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Bigger","product":"core","slug":"tmux-window-bigger"},{"id":"tmux.Window.CellHeight","name":"CellHeight","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CellHeight returns tmux #{window_cell_height} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":998,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.CellHeight","product":"core","slug":"tmux-window-cellheight"},{"id":"tmux.Window.CellWidth","name":"CellWidth","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CellWidth returns tmux #{window_cell_width} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1001,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.CellWidth","product":"core","slug":"tmux-window-cellwidth"},{"id":"tmux.Window.EndFlag","name":"EndFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"EndFlag returns tmux #{window_end_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1004,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.EndFlag","product":"core","slug":"tmux-window-endflag"},{"id":"tmux.Window.Flags","name":"Flags","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Flags returns tmux #{window_flags} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1007,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Flags","product":"core","slug":"tmux-window-flags"},{"id":"tmux.Window.Format","name":"Format","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Format returns tmux #{window_format} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1010,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Format","product":"core","slug":"tmux-window-format"},{"id":"tmux.Window.Height","name":"Height","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Height returns tmux #{window_height} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1013,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Height","product":"core","slug":"tmux-window-height"},{"id":"tmux.Window.LastFlag","name":"LastFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"LastFlag returns tmux #{window_last_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1016,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.LastFlag","product":"core","slug":"tmux-window-lastflag"},{"id":"tmux.Window.Layout","name":"Layout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Layout returns tmux #{window_layout} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1019,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Layout","product":"core","slug":"tmux-window-layout"},{"id":"tmux.Window.Linked","name":"Linked","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Linked returns tmux #{window_linked} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1022,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Linked","product":"core","slug":"tmux-window-linked"},{"id":"tmux.Window.LinkedSessionCount","name":"LinkedSessionCount","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"LinkedSessionCount returns tmux #{window_linked_sessions} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1025,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.LinkedSessionCount","product":"core","slug":"tmux-window-linkedsessioncount"},{"id":"tmux.Window.LinkedSessionsList","name":"LinkedSessionsList","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"LinkedSessionsList returns tmux #{window_linked_sessions_list} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1028,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.LinkedSessionsList","product":"core","slug":"tmux-window-linkedsessionslist"},{"id":"tmux.Window.ManualHeight","name":"ManualHeight","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ManualHeight returns tmux #{window_manual_height} as int from this Window's materialized window-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1033,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ManualHeight","product":"core","slug":"tmux-window-manualheight"},{"id":"tmux.Window.ManualWidth","name":"ManualWidth","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ManualWidth returns tmux #{window_manual_width} as int from this Window's materialized window-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1036,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ManualWidth","product":"core","slug":"tmux-window-manualwidth"},{"id":"tmux.Window.MarkedFlag","name":"MarkedFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MarkedFlag returns tmux #{window_marked_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1039,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.MarkedFlag","product":"core","slug":"tmux-window-markedflag"},{"id":"tmux.Window.Name","name":"Name","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Name returns tmux #{window_name} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1042,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Name","product":"core","slug":"tmux-window-name"},{"id":"tmux.Window.OffsetX","name":"OffsetX","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"OffsetX returns tmux #{window_offset_x} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1045,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.OffsetX","product":"core","slug":"tmux-window-offsetx"},{"id":"tmux.Window.OffsetY","name":"OffsetY","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"OffsetY returns tmux #{window_offset_y} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1048,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.OffsetY","product":"core","slug":"tmux-window-offsety"},{"id":"tmux.Window.PaneCount","name":"PaneCount","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PaneCount returns tmux #{window_panes} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1051,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.PaneCount","product":"core","slug":"tmux-window-panecount"},{"id":"tmux.Window.RawFlags","name":"RawFlags","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"RawFlags returns tmux #{window_raw_flags} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1054,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.RawFlags","product":"core","slug":"tmux-window-rawflags"},{"id":"tmux.Window.SilenceFlag","name":"SilenceFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SilenceFlag returns tmux #{window_silence_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1057,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SilenceFlag","product":"core","slug":"tmux-window-silenceflag"},{"id":"tmux.Window.StackIndex","name":"StackIndex","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"StackIndex returns tmux #{window_stack_index} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1060,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.StackIndex","product":"core","slug":"tmux-window-stackindex"},{"id":"tmux.Window.StartFlag","name":"StartFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"StartFlag returns tmux #{window_start_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1063,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.StartFlag","product":"core","slug":"tmux-window-startflag"},{"id":"tmux.Window.VisibleLayout","name":"VisibleLayout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"VisibleLayout returns tmux #{window_visible_layout} as string from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1066,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.VisibleLayout","product":"core","slug":"tmux-window-visiblelayout"},{"id":"tmux.Window.Width","name":"Width","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Width returns tmux #{window_width} as int from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1069,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Width","product":"core","slug":"tmux-window-width"},{"id":"tmux.Window.ZoomedFlag","name":"ZoomedFlag","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ZoomedFlag returns tmux #{window_zoomed_flag} as bool from this Window's materialized window-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1072,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ZoomedFlag","product":"core","slug":"tmux-window-zoomedflag"},{"id":"tmux.Pane.AlternateOn","name":"AlternateOn","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AlternateOn returns tmux #{alternate_on} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1075,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AlternateOn","product":"core","slug":"tmux-pane-alternateon"},{"id":"tmux.Pane.AlternateSavedX","name":"AlternateSavedX","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"AlternateSavedX returns tmux #{alternate_saved_x} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1078,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AlternateSavedX","product":"core","slug":"tmux-pane-alternatesavedx"},{"id":"tmux.Pane.AlternateSavedY","name":"AlternateSavedY","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"AlternateSavedY returns tmux #{alternate_saved_y} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1081,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AlternateSavedY","product":"core","slug":"tmux-pane-alternatesavedy"},{"id":"tmux.Pane.BracketPasteFlag","name":"BracketPasteFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"BracketPasteFlag returns tmux #{bracket_paste_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1084,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.BracketPasteFlag","product":"core","slug":"tmux-pane-bracketpasteflag"},{"id":"tmux.Pane.CursorBlinking","name":"CursorBlinking","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorBlinking returns tmux #{cursor_blinking} as bool from this Pane's materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":1087,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CursorBlinking","product":"core","slug":"tmux-pane-cursorblinking"},{"id":"tmux.Pane.CursorCharacter","name":"CursorCharacter","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorCharacter returns tmux #{cursor_character} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1090,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CursorCharacter","product":"core","slug":"tmux-pane-cursorcharacter"},{"id":"tmux.Pane.CursorColour","name":"CursorColour","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorColour returns tmux #{cursor_colour} as string from this Pane's materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":1093,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CursorColour","product":"core","slug":"tmux-pane-cursorcolour"},{"id":"tmux.Pane.CursorFlag","name":"CursorFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorFlag returns tmux #{cursor_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1096,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CursorFlag","product":"core","slug":"tmux-pane-cursorflag"},{"id":"tmux.Pane.CursorShape","name":"CursorShape","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CursorShape returns tmux #{cursor_shape} as string from this Pane's materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":1099,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CursorShape","product":"core","slug":"tmux-pane-cursorshape"},{"id":"tmux.Pane.CursorVeryVisible","name":"CursorVeryVisible","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CursorVeryVisible returns tmux #{cursor_very_visible} as bool from this Pane's materialized pane-scoped fields (tmux 3.6 or later)."},"source":{"file":"tmux/format_generated.go","line":1102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CursorVeryVisible","product":"core","slug":"tmux-pane-cursorveryvisible"},{"id":"tmux.Pane.CursorX","name":"CursorX","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CursorX returns tmux #{cursor_x} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1105,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CursorX","product":"core","slug":"tmux-pane-cursorx"},{"id":"tmux.Pane.CursorY","name":"CursorY","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CursorY returns tmux #{cursor_y} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CursorY","product":"core","slug":"tmux-pane-cursory"},{"id":"tmux.Pane.HistoryAdded","name":"HistoryAdded","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryAdded returns tmux #{history_added} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.HistoryAdded","product":"core","slug":"tmux-pane-historyadded"},{"id":"tmux.Pane.HistoryAllBytes","name":"HistoryAllBytes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"HistoryAllBytes returns tmux #{history_all_bytes} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1114,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.HistoryAllBytes","product":"core","slug":"tmux-pane-historyallbytes"},{"id":"tmux.Pane.HistoryBytes","name":"HistoryBytes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryBytes returns tmux #{history_bytes} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1117,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.HistoryBytes","product":"core","slug":"tmux-pane-historybytes"},{"id":"tmux.Pane.HistoryCollected","name":"HistoryCollected","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryCollected returns tmux #{history_collected} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1120,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.HistoryCollected","product":"core","slug":"tmux-pane-historycollected"},{"id":"tmux.Pane.HistoryGeneration","name":"HistoryGeneration","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryGeneration returns tmux #{history_generation} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1123,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.HistoryGeneration","product":"core","slug":"tmux-pane-historygeneration"},{"id":"tmux.Pane.HistoryLimit","name":"HistoryLimit","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistoryLimit returns tmux #{history_limit} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1126,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.HistoryLimit","product":"core","slug":"tmux-pane-historylimit"},{"id":"tmux.Pane.HistorySize","name":"HistorySize","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"HistorySize returns tmux #{history_size} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1129,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.HistorySize","product":"core","slug":"tmux-pane-historysize"},{"id":"tmux.Pane.InsertFlag","name":"InsertFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"InsertFlag returns tmux #{insert_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1132,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.InsertFlag","product":"core","slug":"tmux-pane-insertflag"},{"id":"tmux.Pane.KeypadCursorFlag","name":"KeypadCursorFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"KeypadCursorFlag returns tmux #{keypad_cursor_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1135,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.KeypadCursorFlag","product":"core","slug":"tmux-pane-keypadcursorflag"},{"id":"tmux.Pane.KeypadFlag","name":"KeypadFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"KeypadFlag returns tmux #{keypad_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1138,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.KeypadFlag","product":"core","slug":"tmux-pane-keypadflag"},{"id":"tmux.Pane.MouseAllFlag","name":"MouseAllFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseAllFlag returns tmux #{mouse_all_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1141,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.MouseAllFlag","product":"core","slug":"tmux-pane-mouseallflag"},{"id":"tmux.Pane.MouseAnyFlag","name":"MouseAnyFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseAnyFlag returns tmux #{mouse_any_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.MouseAnyFlag","product":"core","slug":"tmux-pane-mouseanyflag"},{"id":"tmux.Pane.MouseButtonFlag","name":"MouseButtonFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseButtonFlag returns tmux #{mouse_button_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1147,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.MouseButtonFlag","product":"core","slug":"tmux-pane-mousebuttonflag"},{"id":"tmux.Pane.MouseSGRFlag","name":"MouseSGRFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseSGRFlag returns tmux #{mouse_sgr_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1150,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.MouseSGRFlag","product":"core","slug":"tmux-pane-mousesgrflag"},{"id":"tmux.Pane.MouseStandardFlag","name":"MouseStandardFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseStandardFlag returns tmux #{mouse_standard_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1153,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.MouseStandardFlag","product":"core","slug":"tmux-pane-mousestandardflag"},{"id":"tmux.Pane.MouseUTF8Flag","name":"MouseUTF8Flag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MouseUTF8Flag returns tmux #{mouse_utf8_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1156,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.MouseUTF8Flag","product":"core","slug":"tmux-pane-mouseutf8flag"},{"id":"tmux.Pane.OriginFlag","name":"OriginFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"OriginFlag returns tmux #{origin_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1159,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.OriginFlag","product":"core","slug":"tmux-pane-originflag"},{"id":"tmux.Pane.Active","name":"Active","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Active returns tmux #{pane_active} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1162,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Active","product":"core","slug":"tmux-pane-active"},{"id":"tmux.Pane.AtBottom","name":"AtBottom","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AtBottom returns tmux #{pane_at_bottom} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1165,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AtBottom","product":"core","slug":"tmux-pane-atbottom"},{"id":"tmux.Pane.AtLeft","name":"AtLeft","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AtLeft returns tmux #{pane_at_left} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1168,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AtLeft","product":"core","slug":"tmux-pane-atleft"},{"id":"tmux.Pane.AtRight","name":"AtRight","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AtRight returns tmux #{pane_at_right} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1171,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AtRight","product":"core","slug":"tmux-pane-atright"},{"id":"tmux.Pane.AtTop","name":"AtTop","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"AtTop returns tmux #{pane_at_top} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1174,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AtTop","product":"core","slug":"tmux-pane-attop"},{"id":"tmux.Pane.BG","name":"BG","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"BG returns tmux #{pane_bg} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1177,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.BG","product":"core","slug":"tmux-pane-bg"},{"id":"tmux.Pane.Bottom","name":"Bottom","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Bottom returns tmux #{pane_bottom} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1180,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Bottom","product":"core","slug":"tmux-pane-bottom"},{"id":"tmux.Pane.CommandRunning","name":"CommandRunning","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"CommandRunning returns tmux #{pane_command_running} as bool from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1183,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CommandRunning","product":"core","slug":"tmux-pane-commandrunning"},{"id":"tmux.Pane.CurrentCommand","name":"CurrentCommand","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CurrentCommand returns tmux #{pane_current_command} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1186,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CurrentCommand","product":"core","slug":"tmux-pane-currentcommand"},{"id":"tmux.Pane.CurrentPath","name":"CurrentPath","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"CurrentPath returns tmux #{pane_current_path} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1189,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CurrentPath","product":"core","slug":"tmux-pane-currentpath"},{"id":"tmux.Pane.Dead","name":"Dead","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Dead returns tmux #{pane_dead} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1192,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Dead","product":"core","slug":"tmux-pane-dead"},{"id":"tmux.Pane.DeadSignal","name":"DeadSignal","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"DeadSignal returns tmux #{pane_dead_signal} as string from this Pane's materialized pane-scoped fields (tmux 3.3 or later)."},"source":{"file":"tmux/format_generated.go","line":1195,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.DeadSignal","product":"core","slug":"tmux-pane-deadsignal"},{"id":"tmux.Pane.DeadStatus","name":"DeadStatus","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"DeadStatus returns tmux #{pane_dead_status} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1198,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.DeadStatus","product":"core","slug":"tmux-pane-deadstatus"},{"id":"tmux.Pane.DeadTime","name":"DeadTime","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"DeadTime returns tmux #{pane_dead_time} as time.Time from this Pane's materialized pane-scoped fields (tmux 3.3 or later)."},"source":{"file":"tmux/format_generated.go","line":1201,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.DeadTime","product":"core","slug":"tmux-pane-deadtime"},{"id":"tmux.Pane.FG","name":"FG","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"FG returns tmux #{pane_fg} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1204,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.FG","product":"core","slug":"tmux-pane-fg"},{"id":"tmux.Pane.Flags","name":"Flags","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Flags returns tmux #{pane_flags} as string from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1207,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Flags","product":"core","slug":"tmux-pane-flags"},{"id":"tmux.Pane.FloatingFlag","name":"FloatingFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"FloatingFlag returns tmux #{pane_floating_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1210,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.FloatingFlag","product":"core","slug":"tmux-pane-floatingflag"},{"id":"tmux.Pane.Format","name":"Format","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Format returns tmux #{pane_format} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1213,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Format","product":"core","slug":"tmux-pane-format"},{"id":"tmux.Pane.Height","name":"Height","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Height returns tmux #{pane_height} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1216,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Height","product":"core","slug":"tmux-pane-height"},{"id":"tmux.Pane.InMode","name":"InMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"InMode returns tmux #{pane_in_mode} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1219,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.InMode","product":"core","slug":"tmux-pane-inmode"},{"id":"tmux.Pane.InputOff","name":"InputOff","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"InputOff returns tmux #{pane_input_off} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1222,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.InputOff","product":"core","slug":"tmux-pane-inputoff"},{"id":"tmux.Pane.KeyMode","name":"KeyMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"KeyMode returns tmux #{pane_key_mode} as string from this Pane's materialized pane-scoped fields (tmux 3.5 or later)."},"source":{"file":"tmux/format_generated.go","line":1225,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.KeyMode","product":"core","slug":"tmux-pane-keymode"},{"id":"tmux.Pane.Last","name":"Last","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Last returns tmux #{pane_last} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1228,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Last","product":"core","slug":"tmux-pane-last"},{"id":"tmux.Pane.Left","name":"Left","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Left returns tmux #{pane_left} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1231,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Left","product":"core","slug":"tmux-pane-left"},{"id":"tmux.Pane.Marked","name":"Marked","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Marked returns tmux #{pane_marked} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1234,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Marked","product":"core","slug":"tmux-pane-marked"},{"id":"tmux.Pane.MarkedSet","name":"MarkedSet","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"MarkedSet returns tmux #{pane_marked_set} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1237,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.MarkedSet","product":"core","slug":"tmux-pane-markedset"},{"id":"tmux.Pane.ModalFlag","name":"ModalFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ModalFlag returns tmux #{pane_modal_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1240,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ModalFlag","product":"core","slug":"tmux-pane-modalflag"},{"id":"tmux.Pane.Mode","name":"Mode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Mode returns tmux #{pane_mode} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1243,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Mode","product":"core","slug":"tmux-pane-mode"},{"id":"tmux.Pane.OutputGeneration","name":"OutputGeneration","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"OutputGeneration returns tmux #{pane_output_generation} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1246,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.OutputGeneration","product":"core","slug":"tmux-pane-outputgeneration"},{"id":"tmux.Pane.Path","name":"Path","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Path returns tmux #{pane_path} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1249,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Path","product":"core","slug":"tmux-pane-path"},{"id":"tmux.Pane.PBProgress","name":"PBProgress","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PBProgress returns tmux #{pane_pb_progress} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1252,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.PBProgress","product":"core","slug":"tmux-pane-pbprogress"},{"id":"tmux.Pane.PBState","name":"PBState","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PBState returns tmux #{pane_pb_state} as string from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1255,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.PBState","product":"core","slug":"tmux-pane-pbstate"},{"id":"tmux.Pane.ProcessPID","name":"ProcessPID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ProcessPID returns tmux #{pane_pid} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1258,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ProcessPID","product":"core","slug":"tmux-pane-processpid"},{"id":"tmux.Pane.Piping","name":"Piping","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Piping returns tmux #{pane_pipe} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1261,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Piping","product":"core","slug":"tmux-pane-piping"},{"id":"tmux.Pane.PipePID","name":"PipePID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"PipePID returns tmux #{pane_pipe_pid} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1264,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.PipePID","product":"core","slug":"tmux-pane-pipepid"},{"id":"tmux.Pane.PrivateModes","name":"PrivateModes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"PrivateModes returns tmux #{pane_private_modes} as string from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1267,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.PrivateModes","product":"core","slug":"tmux-pane-privatemodes"},{"id":"tmux.Pane.Right","name":"Right","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Right returns tmux #{pane_right} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1270,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Right","product":"core","slug":"tmux-pane-right"},{"id":"tmux.Pane.SearchString","name":"SearchString","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"SearchString returns tmux #{pane_search_string} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1273,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SearchString","product":"core","slug":"tmux-pane-searchstring"},{"id":"tmux.Pane.StartCommand","name":"StartCommand","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"StartCommand returns tmux #{pane_start_command} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1276,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.StartCommand","product":"core","slug":"tmux-pane-startcommand"},{"id":"tmux.Pane.StartCommandList","name":"StartCommandList","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"StartCommandList returns tmux #{pane_start_command_list} as string from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1279,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.StartCommandList","product":"core","slug":"tmux-pane-startcommandlist"},{"id":"tmux.Pane.StartPath","name":"StartPath","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"StartPath returns tmux #{pane_start_path} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1284,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.StartPath","product":"core","slug":"tmux-pane-startpath"},{"id":"tmux.Pane.Synchronized","name":"Synchronized","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Synchronized returns tmux #{pane_synchronized} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1287,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Synchronized","product":"core","slug":"tmux-pane-synchronized"},{"id":"tmux.Pane.Tabs","name":"Tabs","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Tabs returns tmux #{pane_tabs} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1290,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Tabs","product":"core","slug":"tmux-pane-tabs"},{"id":"tmux.Pane.Title","name":"Title","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Title returns tmux #{pane_title} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1293,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Title","product":"core","slug":"tmux-pane-title"},{"id":"tmux.Pane.Top","name":"Top","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Top returns tmux #{pane_top} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1296,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Top","product":"core","slug":"tmux-pane-top"},{"id":"tmux.Pane.TTY","name":"TTY","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TTY returns tmux #{pane_tty} as string from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1299,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.TTY","product":"core","slug":"tmux-pane-tty"},{"id":"tmux.Pane.UnseenChanges","name":"UnseenChanges","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"UnseenChanges returns tmux #{pane_unseen_changes} as bool from this Pane's materialized pane-scoped fields (tmux 3.4 or later)."},"source":{"file":"tmux/format_generated.go","line":1302,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.UnseenChanges","product":"core","slug":"tmux-pane-unseenchanges"},{"id":"tmux.Pane.UnzoomedHeight","name":"UnzoomedHeight","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"UnzoomedHeight returns tmux #{pane_unzoomed_height} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1305,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.UnzoomedHeight","product":"core","slug":"tmux-pane-unzoomedheight"},{"id":"tmux.Pane.UnzoomedWidth","name":"UnzoomedWidth","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"UnzoomedWidth returns tmux #{pane_unzoomed_width} as int from this Pane's materialized pane-scoped fields (tmux 3.8 or later)."},"source":{"file":"tmux/format_generated.go","line":1308,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.UnzoomedWidth","product":"core","slug":"tmux-pane-unzoomedwidth"},{"id":"tmux.Pane.Width","name":"Width","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Width returns tmux #{pane_width} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1311,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Width","product":"core","slug":"tmux-pane-width"},{"id":"tmux.Pane.X","name":"X","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"X returns tmux #{pane_x} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1314,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.X","product":"core","slug":"tmux-pane-x"},{"id":"tmux.Pane.Y","name":"Y","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Y returns tmux #{pane_y} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1317,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Y","product":"core","slug":"tmux-pane-y"},{"id":"tmux.Pane.Z","name":"Z","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Z returns tmux #{pane_z} as int from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1320,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Z","product":"core","slug":"tmux-pane-z"},{"id":"tmux.Pane.ZoomedFlag","name":"ZoomedFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ZoomedFlag returns tmux #{pane_zoomed_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1323,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ZoomedFlag","product":"core","slug":"tmux-pane-zoomedflag"},{"id":"tmux.Pane.ScrollRegionLower","name":"ScrollRegionLower","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ScrollRegionLower returns tmux #{scroll_region_lower} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1326,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ScrollRegionLower","product":"core","slug":"tmux-pane-scrollregionlower"},{"id":"tmux.Pane.ScrollRegionUpper","name":"ScrollRegionUpper","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ScrollRegionUpper returns tmux #{scroll_region_upper} as int from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1329,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ScrollRegionUpper","product":"core","slug":"tmux-pane-scrollregionupper"},{"id":"tmux.Pane.SynchronizedOutputFlag","name":"SynchronizedOutputFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"SynchronizedOutputFlag returns tmux #{synchronized_output_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.7 or later)."},"source":{"file":"tmux/format_generated.go","line":1332,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SynchronizedOutputFlag","product":"core","slug":"tmux-pane-synchronizedoutputflag"},{"id":"tmux.Pane.WrapFlag","name":"WrapFlag","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"WrapFlag returns tmux #{wrap_flag} as bool from this Pane's materialized pane-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1337,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.WrapFlag","product":"core","slug":"tmux-pane-wrapflag"},{"id":"tmux.Client.Activity","name":"Activity","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Activity returns tmux #{client_activity} as time.Time from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1340,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Activity","product":"core","slug":"tmux-client-activity"},{"id":"tmux.Client.CellHeight","name":"CellHeight","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CellHeight returns tmux #{client_cell_height} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1343,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.CellHeight","product":"core","slug":"tmux-client-cellheight"},{"id":"tmux.Client.CellWidth","name":"CellWidth","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"CellWidth returns tmux #{client_cell_width} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1346,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.CellWidth","product":"core","slug":"tmux-client-cellwidth"},{"id":"tmux.Client.ControlMode","name":"ControlMode","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ControlMode returns tmux #{client_control_mode} as bool from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1349,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.ControlMode","product":"core","slug":"tmux-client-controlmode"},{"id":"tmux.Client.Created","name":"Created","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(time.Time, bool)"}],"doc":{"summary":"Created returns tmux #{client_created} as time.Time from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1352,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Created","product":"core","slug":"tmux-client-created"},{"id":"tmux.Client.Discarded","name":"Discarded","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Discarded returns tmux #{client_discarded} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1355,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Discarded","product":"core","slug":"tmux-client-discarded"},{"id":"tmux.Client.Flags","name":"Flags","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Flags returns tmux #{client_flags} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1358,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Flags","product":"core","slug":"tmux-client-flags"},{"id":"tmux.Client.Height","name":"Height","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Height returns tmux #{client_height} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1361,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Height","product":"core","slug":"tmux-client-height"},{"id":"tmux.Client.KeyTable","name":"KeyTable","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"KeyTable returns tmux #{client_key_table} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1364,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.KeyTable","product":"core","slug":"tmux-client-keytable"},{"id":"tmux.Client.LastSession","name":"LastSession","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"LastSession returns tmux #{client_last_session} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1367,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.LastSession","product":"core","slug":"tmux-client-lastsession"},{"id":"tmux.Client.ModeFormat","name":"ModeFormat","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ModeFormat returns tmux #{client_mode_format} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1370,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.ModeFormat","product":"core","slug":"tmux-client-modeformat"},{"id":"tmux.Client.ProcessPID","name":"ProcessPID","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ProcessPID returns tmux #{client_pid} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1373,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.ProcessPID","product":"core","slug":"tmux-client-processpid"},{"id":"tmux.Client.Prefix","name":"Prefix","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"Prefix returns tmux #{client_prefix} as bool from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1376,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Prefix","product":"core","slug":"tmux-client-prefix"},{"id":"tmux.Client.ReadOnly","name":"ReadOnly","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"ReadOnly returns tmux #{client_readonly} as bool from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1379,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.ReadOnly","product":"core","slug":"tmux-client-readonly"},{"id":"tmux.Client.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"Session returns tmux #{client_session} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1382,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Session","product":"core","slug":"tmux-client-session"},{"id":"tmux.Client.TermFeatures","name":"TermFeatures","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TermFeatures returns tmux #{client_termfeatures} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1385,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.TermFeatures","product":"core","slug":"tmux-client-termfeatures"},{"id":"tmux.Client.TermName","name":"TermName","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TermName returns tmux #{client_termname} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1388,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.TermName","product":"core","slug":"tmux-client-termname"},{"id":"tmux.Client.TermType","name":"TermType","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TermType returns tmux #{client_termtype} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1391,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.TermType","product":"core","slug":"tmux-client-termtype"},{"id":"tmux.Client.TTY","name":"TTY","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"TTY returns tmux #{client_tty} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1394,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.TTY","product":"core","slug":"tmux-client-tty"},{"id":"tmux.Client.ProcessUID","name":"ProcessUID","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"ProcessUID returns tmux #{client_uid} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1397,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.ProcessUID","product":"core","slug":"tmux-client-processuid"},{"id":"tmux.Client.ProcessUser","name":"ProcessUser","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(string, bool)"}],"doc":{"summary":"ProcessUser returns tmux #{client_user} as string from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1400,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.ProcessUser","product":"core","slug":"tmux-client-processuser"},{"id":"tmux.Client.UTF8","name":"UTF8","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(bool, bool)"}],"doc":{"summary":"UTF8 returns tmux #{client_utf8} as bool from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1403,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.UTF8","product":"core","slug":"tmux-client-utf8"},{"id":"tmux.Client.Width","name":"Width","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Width returns tmux #{client_width} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1406,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Width","product":"core","slug":"tmux-client-width"},{"id":"tmux.Client.Written","name":"Written","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(int, bool)"}],"doc":{"summary":"Written returns tmux #{client_written} as int from this Client's materialized client-scoped fields (tmux 3.2a or later)."},"source":{"file":"tmux/format_generated.go","line":1409,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Written","product":"core","slug":"tmux-client-written"},{"id":"tmux.ErrNotInsideTmux","name":"ErrNotInsideTmux","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrNotInsideTmux identifies missing or malformed tmux discovery variables."},"source":{"file":"tmux/from_env.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrNotInsideTmux","product":"core","slug":"tmux-errnotinsidetmux"},{"id":"tmux.FromEnvError","name":"FromEnvError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"FromEnvError reports which tmux discovery variable was missing or malformed. It never retains or prints the variable's value."},"source":{"file":"tmux/from_env.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FromEnvError","product":"core","slug":"tmux-fromenverror"},{"id":"tmux.FromEnvError.Variable","name":"Variable","kind":"attribute","modifiers":[],"parent":"tmux.FromEnvError","signatures":[],"type":"string","doc":{"summary":"Variable is the discovery variable name, never its value."},"source":{"file":"tmux/from_env.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FromEnvError.Variable","product":"core","slug":"tmux-fromenverror-variable"},{"id":"tmux.FromEnvError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.FromEnvError","signatures":[],"type":"string","doc":{"summary":"Reason describes why the variable cannot identify a tmux resource."},"source":{"file":"tmux/from_env.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FromEnvError.Reason","product":"core","slug":"tmux-fromenverror-reason"},{"id":"tmux.FromEnvError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.FromEnvError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/from_env.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FromEnvError.Error","product":"core","slug":"tmux-fromenverror-error"},{"id":"tmux.FromEnvError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.FromEnvError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes FromEnvError compatible with ErrNotInsideTmux."},"source":{"file":"tmux/from_env.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FromEnvError.Unwrap","product":"core","slug":"tmux-fromenverror-unwrap"},{"id":"tmux.NewServerFromEnv","name":"NewServerFromEnv","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"environment","type":"map[string]string"}],"returns":"(Server, error)"}],"doc":{"summary":"NewServerFromEnv returns a server configured from TMUX without starting tmux. It snapshots the process environment once. A nonnil environment supplies discovery values and overrides that snapshot for later tmux processes; an empty map therefore has no TMUX discovery value. Names follow the platform's environment rules and are case-insensitive on Windows."},"source":{"file":"tmux/from_env.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewServerFromEnv","product":"core","slug":"tmux-newserverfromenv"},{"id":"tmux.PaneFromEnv","name":"PaneFromEnv","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"environment","type":"map[string]string"}],"returns":"(Pane, error)"}],"doc":{"summary":"PaneFromEnv returns the pane identified by TMUX and TMUX_PANE. Nil reads the process environment; a nonnil empty map does not. Environment names are case-insensitive on Windows. It resolves the live hierarchy later through identity-checked tmux queries."},"source":{"file":"tmux/from_env.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneFromEnv","product":"core","slug":"tmux-panefromenv"},{"id":"tmux.WindowFromEnv","name":"WindowFromEnv","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"environment","type":"map[string]string"}],"returns":"(Window, error)"}],"doc":{"summary":"WindowFromEnv returns the window containing the pane identified by the environment. Nil reads the process environment; a nonnil empty map does not."},"source":{"file":"tmux/from_env.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowFromEnv","product":"core","slug":"tmux-windowfromenv"},{"id":"tmux.SessionFromEnv","name":"SessionFromEnv","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"environment","type":"map[string]string"}],"returns":"(Session, error)"}],"doc":{"summary":"SessionFromEnv returns the canonical session containing the environment's pane. Nil reads the process environment; a nonnil empty map does not."},"source":{"file":"tmux/from_env.go","line":84,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionFromEnv","product":"core","slug":"tmux-sessionfromenv"},{"id":"tmux.Server.Sessions","name":"Sessions","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]Session, error)"}],"doc":{"summary":"Sessions materializes the server's sessions. Failures, including [ErrNoServer], remain errors rather than empty results."},"source":{"file":"tmux/hierarchy.go","line":7,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Sessions","product":"core","slug":"tmux-server-sessions"},{"id":"tmux.Server.Windows","name":"Windows","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]Window, error)"}],"doc":{"summary":"Windows materializes one record per winlink. Failures, including [ErrNoServer], remain errors rather than empty results."},"source":{"file":"tmux/hierarchy.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Windows","product":"core","slug":"tmux-server-windows"},{"id":"tmux.Server.Panes","name":"Panes","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]Pane, error)"}],"doc":{"summary":"Panes materializes pane records for every winlink. Failures, including [ErrNoServer], remain errors rather than empty results."},"source":{"file":"tmux/hierarchy.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Panes","product":"core","slug":"tmux-server-panes"},{"id":"tmux.Server.Clients","name":"Clients","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]Client, error)"}],"doc":{"summary":"Clients materializes attached clients. Failures, including [ErrNoServer], remain errors rather than empty results."},"source":{"file":"tmux/hierarchy.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Clients","product":"core","slug":"tmux-server-clients"},{"id":"tmux.SetHooksOptions","name":"SetHooksOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetHooksOptions controls a bulk hook replacement. Its zero value preserves existing indices before applying the supplied sparse values."},"source":{"file":"tmux/hook_runtime.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetHooksOptions","product":"core","slug":"tmux-sethooksoptions"},{"id":"tmux.SetHooksOptions.ClearExisting","name":"ClearExisting","kind":"attribute","modifiers":[],"parent":"tmux.SetHooksOptions","signatures":[],"type":"bool","doc":{"summary":"ClearExisting unsets every existing index before applying Values."},"source":{"file":"tmux/hook_runtime.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetHooksOptions.ClearExisting","product":"core","slug":"tmux-sethooksoptions-clearexisting"},{"id":"tmux.SetHooksResult","name":"SetHooksResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetHooksResult reports only side effects confirmed before return."},"source":{"file":"tmux/hook_runtime.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetHooksResult","product":"core","slug":"tmux-sethooksresult"},{"id":"tmux.SetHooksResult.Cleared","name":"Cleared","kind":"attribute","modifiers":[],"parent":"tmux.SetHooksResult","signatures":[],"type":"bool","doc":{"summary":"Cleared reports that all existing hook indices were confirmed cleared."},"source":{"file":"tmux/hook_runtime.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetHooksResult.Cleared","product":"core","slug":"tmux-sethooksresult-cleared"},{"id":"tmux.SetHooksResult.AppliedIndices","name":"AppliedIndices","kind":"attribute","modifiers":[],"parent":"tmux.SetHooksResult","signatures":[],"type":"[]int","doc":{"summary":"AppliedIndices is an owned ascending list of indices confirmed applied."},"source":{"file":"tmux/hook_runtime.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetHooksResult.AppliedIndices","product":"core","slug":"tmux-sethooksresult-appliedindices"},{"id":"tmux.GlobalSessionScope.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ServerHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known global session-scope hooks, including inherited values. A read failure is returned rather than answered with zero values."},"source":{"file":"tmux/hook_runtime.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.Hooks","product":"core","slug":"tmux-globalsessionscope-hooks"},{"id":"tmux.GlobalWindowScope.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(WindowHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known global window hooks, including defaults. A read failure is returned rather than answered with zero values; context errors propagate."},"source":{"file":"tmux/hook_runtime.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.Hooks","product":"core","slug":"tmux-globalwindowscope-hooks"},{"id":"tmux.Session.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(SessionHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known hooks at this stable session target, including inherited values. A read failure is returned rather than answered with zero values."},"source":{"file":"tmux/hook_runtime.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Hooks","product":"core","slug":"tmux-session-hooks"},{"id":"tmux.Window.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(WindowHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known hooks at this exact window target, including inherited values. The receiver's exact linked session context controls tmux format evaluation. A read failure is returned rather than answered with zero values."},"source":{"file":"tmux/hook_runtime.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Hooks","product":"core","slug":"tmux-window-hooks"},{"id":"tmux.Pane.Hooks","name":"Hooks","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(PaneHookValues, error)"}],"doc":{"summary":"Hooks returns a freshly decoded, caller-owned view of known hooks at this exact pane target, including inherited values. The receiver's exact linked session context controls tmux format evaluation. A read failure is returned rather than answered with zero values."},"source":{"file":"tmux/hook_runtime.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Hooks","product":"core","slug":"tmux-pane-hooks"},{"id":"tmux.GlobalSessionScope.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact global session-scope hook value. A successful string is caller-owned; ok reports presence. Targeted reads do not use list leniency, and completed failures return a secret-safe option error. An unindexed empty hook array is ambiguous; use Hooks for typed presence."},"source":{"file":"tmux/hook_runtime.go","line":134,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.RawHook","product":"core","slug":"tmux-globalsessionscope-rawhook"},{"id":"tmux.GlobalWindowScope.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact global window-hook value. A successful string is caller-owned; ok reports presence and completed failures are returned. An unindexed empty hook array is ambiguous; use Hooks for typed presence."},"source":{"file":"tmux/hook_runtime.go","line":142,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.RawHook","product":"core","slug":"tmux-globalwindowscope-rawhook"},{"id":"tmux.Session.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact session hook value at this stable session target. A successful string is caller-owned; ok reports presence and completed failures are returned. An unindexed empty hook array is ambiguous; use Hooks for typed presence."},"source":{"file":"tmux/hook_runtime.go","line":153,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.RawHook","product":"core","slug":"tmux-session-rawhook"},{"id":"tmux.Window.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact window hook value at this exact window target. A successful string is caller-owned; the receiver's exact linked session context controls tmux format evaluation, and completed failures are returned."},"source":{"file":"tmux/hook_runtime.go","line":164,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.RawHook","product":"core","slug":"tmux-window-rawhook"},{"id":"tmux.Pane.RawHook","name":"RawHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawHook returns one exact pane hook value at this exact pane target. A successful string is caller-owned; the receiver's exact linked session context controls tmux format evaluation, and completed failures are returned."},"source":{"file":"tmux/hook_runtime.go","line":175,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.RawHook","product":"core","slug":"tmux-pane-rawhook"},{"id":"tmux.GlobalSessionScope.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a global session-scope hook without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":186,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetHook","product":"core","slug":"tmux-globalsessionscope-sethook"},{"id":"tmux.GlobalWindowScope.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a global window hook without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":193,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetHook","product":"core","slug":"tmux-globalwindowscope-sethook"},{"id":"tmux.Session.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a session hook at this stable session target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":208,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetHook","product":"core","slug":"tmux-session-sethook"},{"id":"tmux.Window.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a window hook at this exact window target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":219,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetHook","product":"core","slug":"tmux-window-sethook"},{"id":"tmux.Pane.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHook stores a pane hook at this exact pane target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/hook_runtime.go","line":230,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetHook","product":"core","slug":"tmux-pane-sethook"},{"id":"tmux.GlobalSessionScope.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a global session-scope hook without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":241,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.AppendHook","product":"core","slug":"tmux-globalsessionscope-appendhook"},{"id":"tmux.GlobalWindowScope.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a command to a global window hook without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":248,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.AppendHook","product":"core","slug":"tmux-globalwindowscope-appendhook"},{"id":"tmux.Session.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a session hook at this stable session target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":263,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.AppendHook","product":"core","slug":"tmux-session-appendhook"},{"id":"tmux.Window.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a window hook at this exact window target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":274,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.AppendHook","product":"core","slug":"tmux-window-appendhook"},{"id":"tmux.Pane.AppendHook","name":"AppendHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"command","type":"string"}],"returns":"error"}],"doc":{"summary":"AppendHook appends a pane hook at this exact pane target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the append."},"source":{"file":"tmux/hook_runtime.go","line":285,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AppendHook","product":"core","slug":"tmux-pane-appendhook"},{"id":"tmux.GlobalSessionScope.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching global session-scope hook index without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the unset."},"source":{"file":"tmux/hook_runtime.go","line":296,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.UnsetHook","product":"core","slug":"tmux-globalsessionscope-unsethook"},{"id":"tmux.GlobalWindowScope.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching global window-hook index without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the unset."},"source":{"file":"tmux/hook_runtime.go","line":303,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.UnsetHook","product":"core","slug":"tmux-globalwindowscope-unsethook"},{"id":"tmux.Session.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching session hook index at this stable session target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the unset was accepted."},"source":{"file":"tmux/hook_runtime.go","line":318,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.UnsetHook","product":"core","slug":"tmux-session-unsethook"},{"id":"tmux.Window.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching window hook index at this exact window target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the unset was accepted."},"source":{"file":"tmux/hook_runtime.go","line":329,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.UnsetHook","product":"core","slug":"tmux-window-unsethook"},{"id":"tmux.Pane.UnsetHook","name":"UnsetHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"UnsetHook removes every matching pane hook index at this exact pane target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the unset was accepted."},"source":{"file":"tmux/hook_runtime.go","line":340,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.UnsetHook","product":"core","slug":"tmux-pane-unsethook"},{"id":"tmux.GlobalSessionScope.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one global hook directly. It intentionally performs no racy target preflight; stale targets and global execution context remain tmux-defined. Completed failures are secret-safe option errors; cancellation does not prove hook delivery or execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":352,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.RunHook","product":"core","slug":"tmux-globalsessionscope-runhook"},{"id":"tmux.GlobalWindowScope.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one global window hook directly. It targets global window scope rather than a receiver, returns secret-safe option errors for completed failures, and cancellation does not prove hook delivery or execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":360,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.RunHook","product":"core","slug":"tmux-globalwindowscope-runhook"},{"id":"tmux.Session.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one session hook directly at this stable target. It intentionally performs no racy liveness preflight after validation. Completed failures are secret-safe option errors; cancellation does not prove execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":376,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.RunHook","product":"core","slug":"tmux-session-runhook"},{"id":"tmux.Window.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one window hook directly at this exact target. The receiver's exact linked session context controls tmux format evaluation; no racy preflight is issued. Completed failures are secret-safe option errors; cancellation does not prove execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":388,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.RunHook","product":"core","slug":"tmux-window-runhook"},{"id":"tmux.Pane.RunHook","name":"RunHook","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"RunHook asks tmux to run one pane hook directly at this exact target. The receiver's exact linked session context controls tmux format evaluation; no racy preflight is issued. Completed failures are secret-safe option errors; cancellation does not prove execution did not occur."},"source":{"file":"tmux/hook_runtime.go","line":400,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.RunHook","product":"core","slug":"tmux-pane-runhook"},{"id":"tmux.GlobalSessionScope.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed global session-scope hook commands in ascending order. With ClearExisting it confirms clearing before applying sparse Values. It stops at the first failure without rollback; the returned result reports only confirmed partial progress and owns AppliedIndices. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":413,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetHooks","product":"core","slug":"tmux-globalsessionscope-sethooks"},{"id":"tmux.GlobalWindowScope.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed global window-hook commands in ascending order. With ClearExisting it confirms clearing before applying sparse Values, stops at the first failure without rollback, and reports confirmed progress. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":426,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetHooks","product":"core","slug":"tmux-globalwindowscope-sethooks"},{"id":"tmux.Session.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed session hook commands in ascending order at this handle's stable session target. With ClearExisting it confirms clearing first, stops at the first failure without rollback, and reports confirmed partial progress. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":448,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetHooks","product":"core","slug":"tmux-session-sethooks"},{"id":"tmux.Window.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed window hook commands in ascending order at this handle's exact window target. With ClearExisting it confirms clearing first, stops at the first failure without rollback, and reports confirmed progress. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":465,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetHooks","product":"core","slug":"tmux-window-sethooks"},{"id":"tmux.Pane.SetHooks","name":"SetHooks","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"values","type":"SparseArray[string]"},{"name":"options","type":"SetHooksOptions"}],"returns":"(SetHooksResult, error)"}],"doc":{"summary":"SetHooks applies indexed pane hook commands in ascending order at this handle's exact pane target. With ClearExisting it confirms clearing first, stops at the first failure without rollback, and reports confirmed progress. Cancellation may follow accepted commands and cannot disprove their delivery."},"source":{"file":"tmux/hook_runtime.go","line":482,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetHooks","product":"core","slug":"tmux-pane-sethooks"},{"id":"tmux.ErrDaemonReplaced","name":"ErrDaemonReplaced","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrDaemonReplaced identifies an operation refused because the tmux server instance that produced a materialized value no longer occupies its socket."},"source":{"file":"tmux/identity.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrDaemonReplaced","product":"core","slug":"tmux-errdaemonreplaced"},{"id":"tmux.Server.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"other","type":"Server"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether both handles currently select the same socket path. It evaluates relative paths and environment-dependent named and default sockets against each handle's frozen binding."},"source":{"file":"tmux/identity.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Equal","product":"core","slug":"tmux-server-equal"},{"id":"tmux.Server.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns a concise representation of the server selector."},"source":{"file":"tmux/identity.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.String","product":"core","slug":"tmux-server-string"},{"id":"tmux.Session.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"other","type":"Session"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether two session records carry the same stable ID and tmux server provenance."},"source":{"file":"tmux/identity.go","line":59,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Equal","product":"core","slug":"tmux-session-equal"},{"id":"tmux.Session.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the session's stable ID and queried name."},"source":{"file":"tmux/identity.go","line":64,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.String","product":"core","slug":"tmux-session-string"},{"id":"tmux.Window.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"other","type":"Window"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether two window records carry the same stable window ID. It intentionally collapses linked-session views with different sessions or indexes; use SessionID, WindowID, and WindowIndex for exact view identity."},"source":{"file":"tmux/identity.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Equal","product":"core","slug":"tmux-window-equal"},{"id":"tmux.Window.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the winlink identity and its materialized parent, when present."},"source":{"file":"tmux/identity.go","line":79,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.String","product":"core","slug":"tmux-window-string"},{"id":"tmux.Pane.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"other","type":"Pane"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether two pane records carry the same stable pane ID. It intentionally collapses linked-session views; a pane's exact view identity includes SessionID, WindowID, WindowIndex, and PaneID."},"source":{"file":"tmux/identity.go","line":91,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Equal","product":"core","slug":"tmux-pane-equal"},{"id":"tmux.Pane.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the pane identity and its materialized parent, when present."},"source":{"file":"tmux/identity.go","line":96,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.String","product":"core","slug":"tmux-pane-string"},{"id":"tmux.Client.Equal","name":"Equal","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[{"name":"other","type":"Client"}],"returns":"bool"}],"doc":{"summary":"Equal reports whether two clients carry the same stable client name and tmux server provenance."},"source":{"file":"tmux/identity.go","line":106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Equal","product":"core","slug":"tmux-client-equal"},{"id":"tmux.Client.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the client's stable name."},"source":{"file":"tmux/identity.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.String","product":"core","slug":"tmux-client-string"},{"id":"tmux.ErrInvalidRequest","name":"ErrInvalidRequest","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidRequest identifies lifecycle options rejected before execution."},"source":{"file":"tmux/lifecycle.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidRequest","product":"core","slug":"tmux-errinvalidrequest"},{"id":"tmux.ErrInvalidCommandOutput","name":"ErrInvalidCommandOutput","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidCommandOutput identifies malformed identity output from tmux."},"source":{"file":"tmux/lifecycle.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidCommandOutput","product":"core","slug":"tmux-errinvalidcommandoutput"},{"id":"tmux.PaneDirection","name":"PaneDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneDirection selects where a tiled pane is created or moved on tmux 3.2a or later. Its zero value places the pane below the target."},"source":{"file":"tmux/lifecycle.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneDirection","product":"core","slug":"tmux-panedirection"},{"id":"tmux.PaneDirectionBelow","name":"PaneDirectionBelow","kind":"constant","modifiers":[],"signatures":[],"type":"PaneDirection","doc":{"summary":"PaneDirectionBelow places the pane below the target."},"source":{"file":"tmux/lifecycle.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneDirectionBelow","product":"core","slug":"tmux-panedirectionbelow"},{"id":"tmux.PaneDirectionAbove","name":"PaneDirectionAbove","kind":"constant","modifiers":[],"signatures":[],"type":"PaneDirection","doc":{"summary":"PaneDirectionAbove places the pane above the target."},"source":{"file":"tmux/lifecycle.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneDirectionAbove","product":"core","slug":"tmux-panedirectionabove"},{"id":"tmux.PaneDirectionRight","name":"PaneDirectionRight","kind":"constant","modifiers":[],"signatures":[],"type":"PaneDirection","doc":{"summary":"PaneDirectionRight places the pane to the right of the target."},"source":{"file":"tmux/lifecycle.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneDirectionRight","product":"core","slug":"tmux-panedirectionright"},{"id":"tmux.PaneDirectionLeft","name":"PaneDirectionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"PaneDirection","doc":{"summary":"PaneDirectionLeft places the pane to the left of the target."},"source":{"file":"tmux/lifecycle.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneDirectionLeft","product":"core","slug":"tmux-panedirectionleft"},{"id":"tmux.SessionKillRequest","name":"SessionKillRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionKillRequest configures kill-session on tmux 3.2a or later. Its zero value destroys the receiver session. AllExcept destroys other sessions instead, while ClearAlerts is non-destructive. AllExcept, ClearAlerts, and Group are mutually exclusive because tmux applies a hidden precedence when more than one mode is supplied; the package rejects those combinations before execution. Group's compatibility behavior is documented on that field."},"source":{"file":"tmux/lifecycle_kill.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionKillRequest","product":"core","slug":"tmux-sessionkillrequest"},{"id":"tmux.SessionKillRequest.AllExcept","name":"AllExcept","kind":"attribute","modifiers":[],"parent":"tmux.SessionKillRequest","signatures":[],"type":"bool","doc":{"summary":"AllExcept terminates every other session and detaches their clients while preserving the receiver session."},"source":{"file":"tmux/lifecycle_kill.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionKillRequest.AllExcept","product":"core","slug":"tmux-sessionkillrequest-allexcept"},{"id":"tmux.SessionKillRequest.ClearAlerts","name":"ClearAlerts","kind":"attribute","modifiers":[],"parent":"tmux.SessionKillRequest","signatures":[],"type":"bool","doc":{"summary":"ClearAlerts clears bell, activity, and silence alerts in every window linked to the receiver without destroying a session or detaching its clients."},"source":{"file":"tmux/lifecycle_kill.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionKillRequest.ClearAlerts","product":"core","slug":"tmux-sessionkillrequest-clearalerts"},{"id":"tmux.SessionKillRequest.Group","name":"Group","kind":"attribute","modifiers":[],"parent":"tmux.SessionKillRequest","signatures":[],"type":"bool","doc":{"summary":"Group terminates every session in the receiver's group and detaches their clients. It requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/lifecycle_kill.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionKillRequest.Group","product":"core","slug":"tmux-sessionkillrequest-group"},{"id":"tmux.KillWindowRequest","name":"KillWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"KillWindowRequest selects a window for [Session.KillWindow] on tmux 3.2a or later. A zero request kills the receiver session's current window, and Index is scoped to that session. Target is unrestricted tmux target syntax and may select a window in another session. Target and Index are mutually exclusive and are checked before execution. Pointer values are read during the call and are not retained; callers must not mutate them concurrently. A nil pointer omits its selector, while a nonnil pointer is explicit even when Target points to an empty string."},"source":{"file":"tmux/lifecycle_kill.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.KillWindowRequest","product":"core","slug":"tmux-killwindowrequest"},{"id":"tmux.KillWindowRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.KillWindowRequest","signatures":[],"type":"*string","doc":{"summary":"Target is passed through as unrestricted tmux target syntax when nonnil."},"source":{"file":"tmux/lifecycle_kill.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.KillWindowRequest.Target","product":"core","slug":"tmux-killwindowrequest-target"},{"id":"tmux.KillWindowRequest.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.KillWindowRequest","signatures":[],"type":"*int","doc":{"summary":"Index selects a winlink index within the receiver session when nonnil."},"source":{"file":"tmux/lifecycle_kill.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.KillWindowRequest.Index","product":"core","slug":"tmux-killwindowrequest-index"},{"id":"tmux.Server.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill terminates the configured tmux server and all of its sessions, windows, panes, and clients. After a completed failed kill, a liveness probe makes repeated calls harmless when no daemon answers. Transport or context errors can be delivery-ambiguous; no rollback is attempted.","body":"tmux leaves the socket file in place, so cleanup that waits for the path to\ndisappear does not finish. Use [Server.IsAlive] to observe the daemon, and\nremove a socket path this process chose itself."},"source":{"file":"tmux/lifecycle_kill.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Kill","product":"core","slug":"tmux-server-kill"},{"id":"tmux.Server.KillSession","name":"KillSession","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"target","type":"string"}],"returns":"error"}],"doc":{"summary":"KillSession terminates the session selected by tmux target syntax. Pattern and prefix matching are deliberately left to tmux. Completed nonzero exits without stderr are ignored. Transport and context errors are delivery-ambiguous."},"source":{"file":"tmux/lifecycle_kill.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.KillSession","product":"core","slug":"tmux-server-killsession"},{"id":"tmux.Session.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill destroys the receiver session and removes its winlinks. Ordinary attached clients detach; on tmux 3.6 or later, clients carrying no-detach-on-destroy move to another session when one exists. A window with no remaining links and all of that window's panes are also destroyed. The materialized receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored. Transport errors are delivery-ambiguous. Kill is equivalent to [Session.KillWith] with a zero [SessionKillRequest]."},"source":{"file":"tmux/lifecycle_kill.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Kill","product":"core","slug":"tmux-session-kill"},{"id":"tmux.Session.KillWith","name":"KillWith","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SessionKillRequest"}],"returns":"error"}],"doc":{"summary":"KillWith applies one kill-session mode without refreshing the materialized receiver. The zero request destroys the receiver; AllExcept destroys every other session while preserving the receiver and its current window; ClearAlerts only clears alerts in windows linked to the receiver and leaves sessions, winlinks, panes, client attachments, and current-window selections unchanged. Destroying a session handles clients as [Session.Kill] describes and removes its winlinks; windows left without links and their panes are also destroyed. Group destroys the receiver's group and requires tmux 3.7; on older versions it follows [UnsupportedPolicy].","body":"The three modes are mutually exclusive. Only stderr makes a completed command\na [CommandError]; nonzero exits without stderr are ignored. Transport errors\nare delivery-ambiguous."},"source":{"file":"tmux/lifecycle_kill.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.KillWith","product":"core","slug":"tmux-session-killwith"},{"id":"tmux.Session.KillWindow","name":"KillWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"KillWindowRequest"}],"returns":"error"}],"doc":{"summary":"KillWindow destroys one stable window. When Target and Index are nil it selects the receiver session's current window, and Index selects a winlink in that session. A nonnil Target is forwarded as unrestricted tmux target syntax and may select a window in another session. The selected stable window is removed from every session and its panes are destroyed. Affected sessions preserve their current selection unless this window was current, in which case they select another. A session left without windows is destroyed; [Session.Kill] describes how tmux handles its clients.","body":"Target and Index are mutually exclusive. The receiver is not refreshed. Only\nstderr makes a completed command a [CommandError]; nonzero exits without\nstderr are ignored. Transport errors are delivery-ambiguous."},"source":{"file":"tmux/lifecycle_kill.go","line":169,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.KillWindow","product":"core","slug":"tmux-session-killwindow"},{"id":"tmux.Window.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill destroys the stable window selected by the receiver's WindowID, removes all of its winlinks, and destroys its panes. Affected sessions preserve their current selection unless this window was current, in which case they select another. A session left without windows is destroyed; [Session.Kill] describes how tmux handles its clients. The receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored."},"source":{"file":"tmux/lifecycle_kill.go","line":205,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Kill","product":"core","slug":"tmux-window-kill"},{"id":"tmux.Window.KillOthers","name":"KillOthers","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"KillOthers destroys every other stable window selected through the receiver's exact session and leaves the receiver as that session's current and only window. Links in other sessions are not selected merely because they share the receiver's [WindowID], but every selected stable window is removed from all sessions. Other affected sessions preserve their current selection unless a destroyed window was current, in which case they select another. A session left without windows is destroyed; [Session.Kill] describes how tmux handles its clients. The receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored."},"source":{"file":"tmux/lifecycle_kill.go","line":220,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.KillOthers","product":"core","slug":"tmux-window-killothers"},{"id":"tmux.Pane.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill destroys the receiver pane through its exact linked-pane target. If panes remain and the receiver was active, tmux selects another active pane. If this was the last pane, tmux also destroys the window and removes all of its winlinks. Affected sessions preserve their current selection unless the destroyed window was current, in which case they select another. A session left without windows is destroyed; [Session.Kill] describes how tmux handles its clients. The receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored."},"source":{"file":"tmux/lifecycle_kill.go","line":237,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Kill","product":"core","slug":"tmux-pane-kill"},{"id":"tmux.Pane.KillOthers","name":"KillOthers","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"KillOthers destroys every other pane in the receiver's stable window and leaves the receiver as its sole active pane. It does not select the exact winlink as its session's current window or promise client focus, and it does not destroy a window or session. The receiver is not refreshed. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored."},"source":{"file":"tmux/lifecycle_kill.go","line":247,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.KillOthers","product":"core","slug":"tmux-pane-killothers"},{"id":"tmux.Server.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"id","type":"SessionID"}],"returns":"(Session, error)"}],"doc":{"summary":"Session performs a canonical live lookup of id and returns a newly materialized record. Use [Session.Refresh] when beginning from a record."},"source":{"file":"tmux/lookup.go","line":10,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Session","product":"core","slug":"tmux-server-session"},{"id":"tmux.Server.SessionByName","name":"SessionByName","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(Session, error)"}],"doc":{"summary":"SessionByName performs a live lookup of the session tmux knows by name and returns a newly materialized record. A name no session holds reports [ErrNotFound].","body":"tmux keeps session names unique, so a name identifies one session for as\nlong as it keeps it. A [SessionID] does not change, which is why the records\nthis package hands back carry one and [Server.Session] takes one; a name is\nwhat a person types and what a workspace file records."},"source":{"file":"tmux/lookup.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SessionByName","product":"core","slug":"tmux-server-sessionbyname"},{"id":"tmux.Server.Window","name":"Window","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"id","type":"WindowID"}],"returns":"(Window, error)"}],"doc":{"summary":"Window performs a canonical live lookup of id using tmux's canonical session and returns a newly materialized record. It does not preserve a linked-session view; use [Window.ResolveSession] for that exact relationship."},"source":{"file":"tmux/lookup.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Window","product":"core","slug":"tmux-server-window"},{"id":"tmux.Server.Pane","name":"Pane","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"id","type":"PaneID"}],"returns":"(Pane, error)"}],"doc":{"summary":"Pane performs a canonical live lookup of id using tmux's canonical session and returns a newly materialized record. It does not preserve a linked-session view; use [Pane.ResolveWindow] for that exact relationship."},"source":{"file":"tmux/lookup.go","line":78,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Pane","product":"core","slug":"tmux-server-pane"},{"id":"tmux.Server.Client","name":"Client","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"ClientName"}],"returns":"(Client, error)"}],"doc":{"summary":"Client performs a canonical live lookup of name and returns a new record."},"source":{"file":"tmux/lookup.go","line":93,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Client","product":"core","slug":"tmux-server-client"},{"id":"tmux.Session.Refresh","name":"Refresh","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Session, error)"}],"doc":{"summary":"Refresh performs a canonical live lookup without mutating the receiver."},"source":{"file":"tmux/lookup.go","line":108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Refresh","product":"core","slug":"tmux-session-refresh"},{"id":"tmux.Window.Refresh","name":"Refresh","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"Refresh performs a canonical live lookup for the window's stable ID and returns a new record without mutating the receiver. It does not preserve a linked-session view; use [Window.ResolveSession] for exact relationships."},"source":{"file":"tmux/lookup.go","line":115,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Refresh","product":"core","slug":"tmux-window-refresh"},{"id":"tmux.Pane.Refresh","name":"Refresh","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Pane, error)"}],"doc":{"summary":"Refresh performs a canonical live lookup for the pane's stable ID and returns a new record without mutating the receiver. It does not preserve a linked-session view; use [Pane.ResolveWindow] for exact relationships."},"source":{"file":"tmux/lookup.go","line":122,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Refresh","product":"core","slug":"tmux-pane-refresh"},{"id":"tmux.Client.Refresh","name":"Refresh","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Client, error)"}],"doc":{"summary":"Refresh performs a canonical live lookup without mutating the receiver."},"source":{"file":"tmux/lookup.go","line":127,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Refresh","product":"core","slug":"tmux-client-refresh"},{"id":"tmux.FormatValues.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.FormatValues","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the format expansions as tmux returned them. Nothing decodes: [json.Unmarshal] into this type reports no error and changes nothing, because every field is unexported."},"source":{"file":"tmux/marshal.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FormatValues.MarshalJSON","product":"core","slug":"tmux-formatvalues-marshaljson"},{"id":"tmux.Session.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the session's identity and the format expansions tmux returned for it, under \"formats\". Nothing decodes: a decoded record would carry no [Server], so it could name a session it could never act on, and [json.Unmarshal] into this type reports no error and changes nothing."},"source":{"file":"tmux/marshal.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.MarshalJSON","product":"core","slug":"tmux-session-marshaljson"},{"id":"tmux.Window.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the window's identity, its place in the hierarchy, and the format expansions tmux returned for it. Nothing decodes; see [Session.MarshalJSON]."},"source":{"file":"tmux/marshal.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.MarshalJSON","product":"core","slug":"tmux-window-marshaljson"},{"id":"tmux.Pane.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the pane's identity, its place in the hierarchy, and the format expansions tmux returned for it. Nothing decodes; see [Session.MarshalJSON]."},"source":{"file":"tmux/marshal.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.MarshalJSON","product":"core","slug":"tmux-pane-marshaljson"},{"id":"tmux.Client.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the client's name and the format expansions tmux returned for it. Nothing decodes; see [Session.MarshalJSON]."},"source":{"file":"tmux/marshal.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.MarshalJSON","product":"core","slug":"tmux-client-marshaljson"},{"id":"tmux.Snapshot.MarshalJSON","name":"MarshalJSON","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"([]byte, error)"}],"doc":{"summary":"MarshalJSON encodes the snapshot's tmux version and the records it holds. A kind it listed encodes as an array, empty when tmux reported none; a kind it never listed is absent. Those are different answers, and one field cannot spell both, which is why the arrays are pointers here. Nothing decodes; see [Session.MarshalJSON]."},"source":{"file":"tmux/marshal.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.MarshalJSON","product":"core","slug":"tmux-snapshot-marshaljson"},{"id":"tmux.SessionID","name":"SessionID","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionID is tmux's stable session identifier, including its $ sigil. The zero value is not a usable tmux target."},"source":{"file":"tmux/model.go","line":5,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionID","product":"core","slug":"tmux-sessionid"},{"id":"tmux.SessionID.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.SessionID","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the tmux identifier verbatim."},"source":{"file":"tmux/model.go","line":8,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionID.String","product":"core","slug":"tmux-sessionid-string"},{"id":"tmux.WindowID","name":"WindowID","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowID is tmux's stable window identifier, including its @ sigil. It does not distinguish linked-session views; the zero value is not a usable target."},"source":{"file":"tmux/model.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowID","product":"core","slug":"tmux-windowid"},{"id":"tmux.WindowID.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.WindowID","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the tmux identifier verbatim."},"source":{"file":"tmux/model.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowID.String","product":"core","slug":"tmux-windowid-string"},{"id":"tmux.PaneID","name":"PaneID","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneID is tmux's stable pane identifier, including its % sigil. It does not distinguish linked-session views; the zero value is not a usable target."},"source":{"file":"tmux/model.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneID","product":"core","slug":"tmux-paneid"},{"id":"tmux.PaneID.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneID","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the tmux identifier verbatim."},"source":{"file":"tmux/model.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneID.String","product":"core","slug":"tmux-paneid-string"},{"id":"tmux.ClientName","name":"ClientName","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClientName is tmux's stable client name, normally its terminal path. The zero value is not a usable tmux target."},"source":{"file":"tmux/model.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientName","product":"core","slug":"tmux-clientname"},{"id":"tmux.ClientName.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ClientName","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the tmux client name verbatim."},"source":{"file":"tmux/model.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClientName.String","product":"core","slug":"tmux-clientname-string"},{"id":"tmux.Session","name":"Session","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Session is one materialized tmux session record. It is normally returned by [Server.Snapshot], [Server.Session], or [Session.Refresh]. A zero Session is not a usable tmux target."},"source":{"file":"tmux/model.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session","product":"core","slug":"tmux-session"},{"id":"tmux.Session.ID","name":"ID","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"SessionID"}],"doc":{"summary":"ID returns the stable tmux identity of this session."},"source":{"file":"tmux/model.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ID","product":"core","slug":"tmux-session-id"},{"id":"tmux.Session.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the immutable configured handle that produced the session."},"source":{"file":"tmux/model.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Server","product":"core","slug":"tmux-session-server"},{"id":"tmux.Session.Windows","name":"Windows","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"([]Window, bool)"}],"doc":{"summary":"Windows returns newly allocated shallow copies of this snapshot record's winlink views, and reports whether the receiver carries relations at all.","body":"It never queries tmux. [Server.Snapshot] and the resolvers carry relations; a\ntargeted lookup, refresh, or creation reports false rather than an empty\nrelation. Use [Session.SearchWindows] for current live windows."},"source":{"file":"tmux/model.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Windows","product":"core","slug":"tmux-session-windows"},{"id":"tmux.Session.Panes","name":"Panes","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"([]Pane, bool)"}],"doc":{"summary":"Panes returns newly allocated shallow copies of this snapshot record's pane views, and reports whether the receiver carries relations at all.","body":"It never queries tmux. [Server.Snapshot] and the resolvers carry relations; a\ntargeted lookup, refresh, or creation reports false rather than an empty\nrelation. Use [Session.SearchPanes] for current live panes."},"source":{"file":"tmux/model.go","line":75,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Panes","product":"core","slug":"tmux-session-panes"},{"id":"tmux.Window","name":"Window","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Window is one materialized (session, index, window) winlink record. It is normally returned by [Server.Snapshot], [Server.Window], or [Window.Refresh]. A zero Window is not a usable tmux target."},"source":{"file":"tmux/model.go","line":89,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window","product":"core","slug":"tmux-window"},{"id":"tmux.Window.SessionID","name":"SessionID","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"SessionID"}],"doc":{"summary":"SessionID returns the linked session containing this view."},"source":{"file":"tmux/model.go","line":99,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SessionID","product":"core","slug":"tmux-window-sessionid"},{"id":"tmux.Window.ID","name":"ID","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"WindowID"}],"doc":{"summary":"ID returns the underlying stable tmux window identity."},"source":{"file":"tmux/model.go","line":102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ID","product":"core","slug":"tmux-window-id"},{"id":"tmux.Window.Index","name":"Index","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Index returns this window's index in its linked session. It returns -1 for a partial Window whose exact winlink has not been materialized."},"source":{"file":"tmux/model.go","line":106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Index","product":"core","slug":"tmux-window-index"},{"id":"tmux.Window.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the configured handle that produced the window."},"source":{"file":"tmux/model.go","line":109,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Server","product":"core","slug":"tmux-window-server"},{"id":"tmux.Window.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(Session, bool)"}],"doc":{"summary":"Session returns this view's parent record when it remains in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Session","product":"core","slug":"tmux-window-session"},{"id":"tmux.Window.Panes","name":"Panes","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"([]Pane, bool)"}],"doc":{"summary":"Panes returns newly allocated shallow copies of panes for this exact winlink, and reports whether the receiver carries relations at all.","body":"It never queries tmux. [Server.Snapshot], the resolvers, and\n[Session.NewWindow] carry relations; a targeted lookup or refresh reports\nfalse instead. Use [Window.SearchPanes] for current live panes."},"source":{"file":"tmux/model.go","line":135,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Panes","product":"core","slug":"tmux-window-panes"},{"id":"tmux.Pane","name":"Pane","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Pane is one materialized pane record within a specific winlink. It is normally returned by [Server.Snapshot], [Server.Pane], or [Pane.Refresh]. A zero Pane is not a usable tmux target."},"source":{"file":"tmux/model.go","line":150,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane","product":"core","slug":"tmux-pane"},{"id":"tmux.Pane.SessionID","name":"SessionID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"SessionID"}],"doc":{"summary":"SessionID returns the linked session containing this pane view."},"source":{"file":"tmux/model.go","line":162,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SessionID","product":"core","slug":"tmux-pane-sessionid"},{"id":"tmux.Pane.WindowID","name":"WindowID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"WindowID"}],"doc":{"summary":"WindowID returns the underlying stable tmux window identity."},"source":{"file":"tmux/model.go","line":165,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.WindowID","product":"core","slug":"tmux-pane-windowid"},{"id":"tmux.Pane.WindowIndex","name":"WindowIndex","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"WindowIndex returns this pane view's window index in its linked session."},"source":{"file":"tmux/model.go","line":168,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.WindowIndex","product":"core","slug":"tmux-pane-windowindex"},{"id":"tmux.Pane.ID","name":"ID","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"PaneID"}],"doc":{"summary":"ID returns the stable tmux pane identity."},"source":{"file":"tmux/model.go","line":171,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ID","product":"core","slug":"tmux-pane-id"},{"id":"tmux.Pane.Index","name":"Index","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Index returns the pane's index in its exact window view. Unlike the materialized format accessors it sits beside, it returns a plain int, because a pane record always carries the index tmux placed it at."},"source":{"file":"tmux/model.go","line":176,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Index","product":"core","slug":"tmux-pane-index"},{"id":"tmux.Pane.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the configured handle that produced the pane."},"source":{"file":"tmux/model.go","line":179,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Server","product":"core","slug":"tmux-pane-server"},{"id":"tmux.Pane.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(Session, bool)"}],"doc":{"summary":"Session returns this view's parent record when it remains in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":188,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Session","product":"core","slug":"tmux-pane-session"},{"id":"tmux.Pane.Window","name":"Window","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"(Window, bool)"}],"doc":{"summary":"Window returns this pane's exact winlink record when it remains in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":201,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Window","product":"core","slug":"tmux-pane-window"},{"id":"tmux.Client","name":"Client","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Client is one materialized tmux client record. It is normally returned by [Server.Snapshot], [Server.Client], or [Client.Refresh]. A zero Client is not a usable tmux target."},"source":{"file":"tmux/model.go","line":216,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client","product":"core","slug":"tmux-client"},{"id":"tmux.Client.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the configured handle that produced the client."},"source":{"file":"tmux/model.go","line":235,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Server","product":"core","slug":"tmux-client-server"},{"id":"tmux.Client.Name","name":"Name","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"ClientName"}],"doc":{"summary":"Name returns the stable tmux name of this client."},"source":{"file":"tmux/model.go","line":238,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.Name","product":"core","slug":"tmux-client-name"},{"id":"tmux.Client.AttachedSession","name":"AttachedSession","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(Session, bool)"}],"doc":{"summary":"AttachedSession returns the materialized attached session, if present in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":242,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.AttachedSession","product":"core","slug":"tmux-client-attachedsession"},{"id":"tmux.Client.AttachedWindow","name":"AttachedWindow","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(Window, bool)"}],"doc":{"summary":"AttachedWindow returns the client's exact materialized winlink, if present in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":255,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.AttachedWindow","product":"core","slug":"tmux-client-attachedwindow"},{"id":"tmux.Client.AttachedPane","name":"AttachedPane","kind":"method","modifiers":[],"parent":"tmux.Client","signatures":[{"params":[],"returns":"(Pane, bool)"}],"doc":{"summary":"AttachedPane returns the client's exact materialized pane view, if present in the same snapshot. It never queries tmux."},"source":{"file":"tmux/model.go","line":273,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Client.AttachedPane","product":"core","slug":"tmux-client-attachedpane"},{"id":"tmux.NotificationStream","name":"NotificationStream","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NotificationStream owns one observation-only control client attached to a session. It yields tmux notifications in wire order and must be closed. Before tmux 3.6, destroying the attached session follows that session's detach-on-destroy policy and may end the stream."},"source":{"file":"tmux/notification_stream.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationStream","product":"core","slug":"tmux-notificationstream"},{"id":"tmux.NotificationOptions","name":"NotificationOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NotificationOptions configures which notifications a stream receives. The zero value retains notifications other than pane output."},"source":{"file":"tmux/notification_stream.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationOptions","product":"core","slug":"tmux-notificationoptions"},{"id":"tmux.NotificationOptions.IncludePaneOutput","name":"IncludePaneOutput","kind":"attribute","modifiers":[],"parent":"tmux.NotificationOptions","signatures":[],"type":"bool","doc":{"summary":"IncludePaneOutput includes output and extended-output notifications."},"source":{"file":"tmux/notification_stream.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationOptions.IncludePaneOutput","product":"core","slug":"tmux-notificationoptions-includepaneoutput"},{"id":"tmux.NotificationOptions.PauseAfter","name":"PauseAfter","kind":"attribute","modifiers":[],"parent":"tmux.NotificationOptions","signatures":[],"type":"time.Duration","doc":{"summary":"PauseAfter asks tmux to hold a pane's output once this stream is that far behind on it, and to say so with a pause notification. Zero leaves tmux's own behavior, which ends a stream that falls five minutes behind rather than pausing it. tmux resolves this to whole seconds, and it governs pane output, so it requires IncludePaneOutput."},"source":{"file":"tmux/notification_stream.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationOptions.PauseAfter","product":"core","slug":"tmux-notificationoptions-pauseafter"},{"id":"tmux.Server.OpenNotifications","name":"OpenNotifications","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"session","type":"Session"},{"name":"options","type":"NotificationOptions"}],"returns":"(*NotificationStream, error)"}],"doc":{"summary":"OpenNotifications starts an owned observation-only stream attached to session. Session must belong to the same configured server selector. A connection-bound server returns [ErrConnectionRequiresProcess]."},"source":{"file":"tmux/notification_stream.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.OpenNotifications","product":"core","slug":"tmux-server-opennotifications"},{"id":"tmux.NotificationStream.ContinuePane","name":"ContinuePane","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"pane","type":"PaneID"}],"returns":"error"}],"doc":{"summary":"ContinuePane resumes pane output tmux held after this stream fell behind on it. tmux does not replay what it held, so read the pane to recover that span rather than waiting for it. Resuming a pane tmux never paused does nothing and reports nothing, because tmux answers neither."},"source":{"file":"tmux/notification_stream.go","line":91,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationStream.ContinuePane","product":"core","slug":"tmux-notificationstream-continuepane"},{"id":"tmux.SubscriptionRequest","name":"SubscriptionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SubscriptionRequest names a format for tmux to evaluate and report on this stream whenever its value changes. Its zero value is invalid because Name and Format are required. At most one of Session, Window, and Pane scopes the evaluation; none evaluates against the stream's attached session.","body":"tmux stops evaluating a pane-scoped subscription once that pane's process has\nexited, so a subscription that must observe pane death is scoped to the\nwindow and reads the pane from the change it reports."},"source":{"file":"tmux/notification_stream.go","line":115,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionRequest","product":"core","slug":"tmux-subscriptionrequest"},{"id":"tmux.SubscriptionRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"string","doc":{"summary":"Name identifies the subscription in each change and to Unsubscribe. It may not contain a colon or a space."},"source":{"file":"tmux/notification_stream.go","line":118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionRequest.Name","product":"core","slug":"tmux-subscriptionrequest-name"},{"id":"tmux.SubscriptionRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"string","doc":{"summary":"Format is the tmux format to evaluate, such as #{pane_current_command}."},"source":{"file":"tmux/notification_stream.go","line":120,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionRequest.Format","product":"core","slug":"tmux-subscriptionrequest-format"},{"id":"tmux.SubscriptionRequest.Session","name":"Session","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"SessionID","doc":{"summary":"Session scopes evaluation to the stream's attached session. tmux always evaluates a session-scoped subscription against the control client's own session, so this only requests that scope; it is not a selector, and any value is equivalent to the stream's own session."},"source":{"file":"tmux/notification_stream.go","line":125,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionRequest.Session","product":"core","slug":"tmux-subscriptionrequest-session"},{"id":"tmux.SubscriptionRequest.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"WindowID","doc":{"summary":"Window scopes evaluation to one window."},"source":{"file":"tmux/notification_stream.go","line":127,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionRequest.Window","product":"core","slug":"tmux-subscriptionrequest-window"},{"id":"tmux.SubscriptionRequest.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.SubscriptionRequest","signatures":[],"type":"PaneID","doc":{"summary":"Pane scopes evaluation to one pane."},"source":{"file":"tmux/notification_stream.go","line":129,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SubscriptionRequest.Pane","product":"core","slug":"tmux-subscriptionrequest-pane"},{"id":"tmux.NotificationStream.Subscribe","name":"Subscribe","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SubscriptionRequest"}],"returns":"error"}],"doc":{"summary":"Subscribe asks tmux to evaluate request's format and report it on this stream as a subscription-changed notification, read with [ControlNotification.Subscription]. tmux reports the value at its next evaluation, about a second later, and then each time it changes. Arming a name already armed replaces its format."},"source":{"file":"tmux/notification_stream.go","line":189,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationStream.Subscribe","product":"core","slug":"tmux-notificationstream-subscribe"},{"id":"tmux.NotificationStream.Unsubscribe","name":"Unsubscribe","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"Unsubscribe stops the subscription armed under name. Stopping a name that was never armed does nothing and reports nothing, because tmux answers neither."},"source":{"file":"tmux/notification_stream.go","line":204,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationStream.Unsubscribe","product":"core","slug":"tmux-notificationstream-unsubscribe"},{"id":"tmux.Session.OpenNotifications","name":"OpenNotifications","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"options","type":"NotificationOptions"}],"returns":"(*NotificationStream, error)"}],"doc":{"summary":"OpenNotifications starts an owned notification stream attached to the receiver. It does not change the receiver's transport or expose control commands. A connection-bound receiver returns [ErrConnectionRequiresProcess]."},"source":{"file":"tmux/notification_stream.go","line":233,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.OpenNotifications","product":"core","slug":"tmux-session-opennotifications"},{"id":"tmux.NotificationStream.Next","name":"Next","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ControlNotification, error)"}],"doc":{"summary":"Next returns the next ordered control-mode notification. Exactly one caller may use Next at a time."},"source":{"file":"tmux/notification_stream.go","line":242,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationStream.Next","product":"core","slug":"tmux-notificationstream-next"},{"id":"tmux.NotificationStream.Notifications","name":"Notifications","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"iter.Seq2[ControlNotification, error]"}],"doc":{"summary":"Notifications returns [NotificationStream.Next] as a range loop; exactly one iterator or direct read may run at a time. Malformed notifications yield their error and iteration continues; every other error ends the loop after being yielded."},"source":{"file":"tmux/notification_stream.go","line":255,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationStream.Notifications","product":"core","slug":"tmux-notificationstream-notifications"},{"id":"tmux.NotificationStream.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts idempotent stream shutdown and waits within ctx. The context bounds only the wait; a later call may resume waiting for shutdown."},"source":{"file":"tmux/notification_stream.go","line":263,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationStream.CloseContext","product":"core","slug":"tmux-notificationstream-closecontext"},{"id":"tmux.NotificationStream.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmux.NotificationStream","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the notification stream. It is safe to call concurrently and more than once."},"source":{"file":"tmux/notification_stream.go","line":272,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NotificationStream.Close","product":"core","slug":"tmux-notificationstream-close"},{"id":"tmux.CommandTransport","name":"CommandTransport","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandTransport names how one tmux command reached tmux."},"source":{"file":"tmux/observer.go","line":9,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTransport","product":"core","slug":"tmux-commandtransport"},{"id":"tmux.CommandTransportProcess","name":"CommandTransportProcess","kind":"constant","modifiers":[],"signatures":[],"type":"CommandTransport","doc":{"summary":"CommandTransportProcess ran the command as its own tmux process."},"source":{"file":"tmux/observer.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTransportProcess","product":"core","slug":"tmux-commandtransportprocess"},{"id":"tmux.CommandTransportConnection","name":"CommandTransportConnection","kind":"constant","modifiers":[],"signatures":[],"type":"CommandTransport","doc":{"summary":"CommandTransportConnection carried the command over a control-mode connection opened earlier."},"source":{"file":"tmux/observer.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTransportConnection","product":"core","slug":"tmux-commandtransportconnection"},{"id":"tmux.CommandTransport.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.CommandTransport","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer."},"source":{"file":"tmux/observer.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTransport.String","product":"core","slug":"tmux-commandtransport-string"},{"id":"tmux.CommandTrace","name":"CommandTrace","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandTrace records one completed attempt to run a tmux command. It carries neither the argument vector nor tmux's output, both of which may hold passwords, tokens, or pane contents; [CommandError] is where a caller that accepts that reads them."},"source":{"file":"tmux/observer.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTrace","product":"core","slug":"tmux-commandtrace"},{"id":"tmux.CommandTrace.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"string","doc":{"summary":"Subcommand is the tmux subcommand, such as \"list-sessions\". A raw command list reports its first subcommand."},"source":{"file":"tmux/observer.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTrace.Subcommand","product":"core","slug":"tmux-commandtrace-subcommand"},{"id":"tmux.CommandTrace.Transport","name":"Transport","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"CommandTransport","doc":{"summary":"Transport names how the command reached tmux."},"source":{"file":"tmux/observer.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTrace.Transport","product":"core","slug":"tmux-commandtrace-transport"},{"id":"tmux.CommandTrace.Duration","name":"Duration","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"time.Duration","doc":{"summary":"Duration is how long the attempt took."},"source":{"file":"tmux/observer.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTrace.Duration","product":"core","slug":"tmux-commandtrace-duration"},{"id":"tmux.CommandTrace.ExitCode","name":"ExitCode","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"int","doc":{"summary":"ExitCode is tmux's exit code, or -1 when no tmux command ran."},"source":{"file":"tmux/observer.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTrace.ExitCode","product":"core","slug":"tmux-commandtrace-exitcode"},{"id":"tmux.CommandTrace.Err","name":"Err","kind":"attribute","modifiers":[],"parent":"tmux.CommandTrace","signatures":[],"type":"error","doc":{"summary":"Err is the transport or validation failure, if any. A completed tmux command that failed leaves this nil and reports through ExitCode."},"source":{"file":"tmux/observer.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTrace.Err","product":"core","slug":"tmux-commandtrace-err"},{"id":"tmux.CommandTrace.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.CommandTrace","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer."},"source":{"file":"tmux/observer.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandTrace.String","product":"core","slug":"tmux-commandtrace-string"},{"id":"tmux.CommandObserver","name":"CommandObserver","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandObserver receives one [CommandTrace] per tmux command a [Server] and the values derived from it run:","body":"server, err := tmux.NewServer(tmux.ServerOptions{\n\tCommandObserver: func(trace tmux.CommandTrace) {\n\t\tslog.Info(\"tmux\", \"command\", trace.Subcommand,\n\t\t\t\"transport\", trace.Transport.String(),\n\t\t\t\"duration\", trace.Duration, \"exit\", trace.ExitCode)\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\n\nIt is called synchronously on the goroutine that ran the command, after the\ncommand finishes and before its result is returned, so a slow observer slows\nevery command. Operations may invoke it concurrently; synchronize shared\nstate. A nil observer costs nothing, not even the clock reads.\n\nIt sees the version probes this package runs on its own behalf, and the\nidentity probe a daemon guard runs to decide whether a failure was a\nreplaced daemon, so one call can produce more than one trace."},"source":{"file":"tmux/observer.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandObserver","product":"core","slug":"tmux-commandobserver"},{"id":"tmux.ErrMalformedOptionOutput","name":"ErrMalformedOptionOutput","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedOptionOutput identifies a recognized option or hook record that cannot be decoded without ambiguity. It is matched by errors.Is for OptionDecodeError."},"source":{"file":"tmux/option_decode.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrMalformedOptionOutput","product":"core","slug":"tmux-errmalformedoptionoutput"},{"id":"tmux.OptionDecodeError","name":"OptionDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionDecodeError reports a malformed recognized record without retaining its value. It matches [ErrMalformedOptionOutput] through errors.Is; callers can recover Record and Reason with errors.As. Record is the zero-based physical output line."},"source":{"file":"tmux/option_decode.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionDecodeError","product":"core","slug":"tmux-optiondecodeerror"},{"id":"tmux.OptionDecodeError.Record","name":"Record","kind":"attribute","modifiers":[],"parent":"tmux.OptionDecodeError","signatures":[],"type":"int","doc":{"summary":"Record is the zero-based physical output line."},"source":{"file":"tmux/option_decode.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionDecodeError.Record","product":"core","slug":"tmux-optiondecodeerror-record"},{"id":"tmux.OptionDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.OptionDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes the malformed record without retaining its value."},"source":{"file":"tmux/option_decode.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionDecodeError.Reason","product":"core","slug":"tmux-optiondecodeerror-reason"},{"id":"tmux.OptionDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.OptionDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/option_decode.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionDecodeError.Error","product":"core","slug":"tmux-optiondecodeerror-error"},{"id":"tmux.OptionDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.OptionDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes OptionDecodeError compatible with ErrMalformedOptionOutput."},"source":{"file":"tmux/option_decode.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionDecodeError.Unwrap","product":"core","slug":"tmux-optiondecodeerror-unwrap"},{"id":"tmux.ErrOption","name":"ErrOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrOption identifies a failed high-level option or hook operation. It is matched by errors.Is for OptionError."},"source":{"file":"tmux/option_error.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrOption","product":"core","slug":"tmux-erroption"},{"id":"tmux.ErrUnknownOption","name":"ErrUnknownOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrUnknownOption identifies tmux's case-sensitive unknown-option diagnostic."},"source":{"file":"tmux/option_error.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrUnknownOption","product":"core","slug":"tmux-errunknownoption"},{"id":"tmux.ErrInvalidOption","name":"ErrInvalidOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidOption identifies tmux's case-sensitive invalid-option diagnostic."},"source":{"file":"tmux/option_error.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidOption","product":"core","slug":"tmux-errinvalidoption"},{"id":"tmux.ErrInvalidOptionValue","name":"ErrInvalidOptionValue","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidOptionValue identifies a typed option value outside its active tmux-version domain."},"source":{"file":"tmux/option_error.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidOptionValue","product":"core","slug":"tmux-errinvalidoptionvalue"},{"id":"tmux.ErrAmbiguousOption","name":"ErrAmbiguousOption","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrAmbiguousOption identifies tmux's case-sensitive ambiguous-option diagnostic."},"source":{"file":"tmux/option_error.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrAmbiguousOption","product":"core","slug":"tmux-errambiguousoption"},{"id":"tmux.ErrOptionTarget","name":"ErrOptionTarget","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrOptionTarget identifies an option or hook operation whose target did not resolve, which is the failure an unknown name is most easily mistaken for. Classifying it discloses nothing that redaction protects: which kind of failure occurred is not one of the values or hook commands an option error withholds."},"source":{"file":"tmux/option_error.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrOptionTarget","product":"core","slug":"tmux-erroptiontarget"},{"id":"tmux.OptionValueError","name":"OptionValueError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionValueError reports a rejected typed option value without retaining or rendering that value. It matches [ErrInvalidOptionValue] and [ErrOption]."},"source":{"file":"tmux/option_error.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionValueError","product":"core","slug":"tmux-optionvalueerror"},{"id":"tmux.OptionValueError.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.OptionValueError","signatures":[],"type":"string","doc":{"summary":"Name is the safe, generated tmux option name."},"source":{"file":"tmux/option_error.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionValueError.Name","product":"core","slug":"tmux-optionvalueerror-name"},{"id":"tmux.OptionValueError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.OptionValueError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error without disclosing the attempted value."},"source":{"file":"tmux/option_error.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionValueError.Error","product":"core","slug":"tmux-optionvalueerror-error"},{"id":"tmux.OptionValueError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.OptionValueError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes OptionValueError compatible with ErrInvalidOptionValue."},"source":{"file":"tmux/option_error.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionValueError.Unwrap","product":"core","slug":"tmux-optionvalueerror-unwrap"},{"id":"tmux.OptionError","name":"OptionError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionError reports a completed high-level option or hook failure. It matches [ErrOption] and a specific option sentinel through errors.Is; callers can recover its fields with errors.As. Library-created errors retain only Result.ExitCode. Error never renders command output because option values and hook commands may be secret; callers may construct exported values with other contents."},"source":{"file":"tmux/option_error.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionError","product":"core","slug":"tmux-optionerror"},{"id":"tmux.OptionError.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.OptionError","signatures":[],"type":"string","doc":{"summary":"Subcommand is the failed tmux option or hook subcommand."},"source":{"file":"tmux/option_error.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionError.Subcommand","product":"core","slug":"tmux-optionerror-subcommand"},{"id":"tmux.OptionError.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.OptionError","signatures":[],"type":"string","doc":{"summary":"Name is the option or hook name, when available."},"source":{"file":"tmux/option_error.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionError.Name","product":"core","slug":"tmux-optionerror-name"},{"id":"tmux.OptionError.Result","name":"Result","kind":"attribute","modifiers":[],"parent":"tmux.OptionError","signatures":[],"type":"CommandResult","doc":{"summary":"Result contains the library-created error's exit code and no diagnostics."},"source":{"file":"tmux/option_error.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionError.Result","product":"core","slug":"tmux-optionerror-result"},{"id":"tmux.OptionError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.OptionError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/option_error.go","line":72,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionError.Error","product":"core","slug":"tmux-optionerror-error"},{"id":"tmux.OptionError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.OptionError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes OptionError compatible with ErrOption and its specific kinds."},"source":{"file":"tmux/option_error.go","line":102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionError.Unwrap","product":"core","slug":"tmux-optionerror-unwrap"},{"id":"tmux.ActivityAction","name":"ActivityAction","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ActivityAction is a typed value for the \"activity-action\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":11,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ActivityAction","product":"core","slug":"tmux-activityaction"},{"id":"tmux.ActivityActionNone","name":"ActivityActionNone","kind":"constant","modifiers":[],"signatures":[],"type":"ActivityAction","doc":{"summary":"ActivityActionNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ActivityActionNone","product":"core","slug":"tmux-activityactionnone"},{"id":"tmux.ActivityActionAny","name":"ActivityActionAny","kind":"constant","modifiers":[],"signatures":[],"type":"ActivityAction","doc":{"summary":"ActivityActionAny selects \"any\"."},"source":{"file":"tmux/option_generated.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ActivityActionAny","product":"core","slug":"tmux-activityactionany"},{"id":"tmux.ActivityActionCurrent","name":"ActivityActionCurrent","kind":"constant","modifiers":[],"signatures":[],"type":"ActivityAction","doc":{"summary":"ActivityActionCurrent selects \"current\"."},"source":{"file":"tmux/option_generated.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ActivityActionCurrent","product":"core","slug":"tmux-activityactioncurrent"},{"id":"tmux.ActivityActionOther","name":"ActivityActionOther","kind":"constant","modifiers":[],"signatures":[],"type":"ActivityAction","doc":{"summary":"ActivityActionOther selects \"other\"."},"source":{"file":"tmux/option_generated.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ActivityActionOther","product":"core","slug":"tmux-activityactionother"},{"id":"tmux.ActivityAction.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ActivityAction","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ActivityAction.String","product":"core","slug":"tmux-activityaction-string"},{"id":"tmux.ActivityAction.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ActivityAction","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ActivityAction.Valid","product":"core","slug":"tmux-activityaction-valid"},{"id":"tmux.AllowPassthrough","name":"AllowPassthrough","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"AllowPassthrough is a typed value for the \"allow-passthrough\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AllowPassthrough","product":"core","slug":"tmux-allowpassthrough"},{"id":"tmux.AllowPassthroughOff","name":"AllowPassthroughOff","kind":"constant","modifiers":[],"signatures":[],"type":"AllowPassthrough","doc":{"summary":"AllowPassthroughOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AllowPassthroughOff","product":"core","slug":"tmux-allowpassthroughoff"},{"id":"tmux.AllowPassthroughOn","name":"AllowPassthroughOn","kind":"constant","modifiers":[],"signatures":[],"type":"AllowPassthrough","doc":{"summary":"AllowPassthroughOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AllowPassthroughOn","product":"core","slug":"tmux-allowpassthroughon"},{"id":"tmux.AllowPassthroughAll","name":"AllowPassthroughAll","kind":"constant","modifiers":[],"signatures":[],"type":"AllowPassthrough","doc":{"summary":"AllowPassthroughAll selects \"all\"."},"source":{"file":"tmux/option_generated.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AllowPassthroughAll","product":"core","slug":"tmux-allowpassthroughall"},{"id":"tmux.AllowPassthrough.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.AllowPassthrough","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AllowPassthrough.String","product":"core","slug":"tmux-allowpassthrough-string"},{"id":"tmux.AllowPassthrough.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.AllowPassthrough","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AllowPassthrough.Valid","product":"core","slug":"tmux-allowpassthrough-valid"},{"id":"tmux.BellAction","name":"BellAction","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"BellAction is a typed value for the \"bell-action\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BellAction","product":"core","slug":"tmux-bellaction"},{"id":"tmux.BellActionNone","name":"BellActionNone","kind":"constant","modifiers":[],"signatures":[],"type":"BellAction","doc":{"summary":"BellActionNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BellActionNone","product":"core","slug":"tmux-bellactionnone"},{"id":"tmux.BellActionAny","name":"BellActionAny","kind":"constant","modifiers":[],"signatures":[],"type":"BellAction","doc":{"summary":"BellActionAny selects \"any\"."},"source":{"file":"tmux/option_generated.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BellActionAny","product":"core","slug":"tmux-bellactionany"},{"id":"tmux.BellActionCurrent","name":"BellActionCurrent","kind":"constant","modifiers":[],"signatures":[],"type":"BellAction","doc":{"summary":"BellActionCurrent selects \"current\"."},"source":{"file":"tmux/option_generated.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BellActionCurrent","product":"core","slug":"tmux-bellactioncurrent"},{"id":"tmux.BellActionOther","name":"BellActionOther","kind":"constant","modifiers":[],"signatures":[],"type":"BellAction","doc":{"summary":"BellActionOther selects \"other\"."},"source":{"file":"tmux/option_generated.go","line":73,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BellActionOther","product":"core","slug":"tmux-bellactionother"},{"id":"tmux.BellAction.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.BellAction","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BellAction.String","product":"core","slug":"tmux-bellaction-string"},{"id":"tmux.BellAction.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.BellAction","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BellAction.Valid","product":"core","slug":"tmux-bellaction-valid"},{"id":"tmux.ClockModeStyle","name":"ClockModeStyle","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClockModeStyle is a typed value for the \"clock-mode-style\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClockModeStyle","product":"core","slug":"tmux-clockmodestyle"},{"id":"tmux.ClockModeStyle12","name":"ClockModeStyle12","kind":"constant","modifiers":[],"signatures":[],"type":"ClockModeStyle","doc":{"summary":"ClockModeStyle12 selects \"12\"."},"source":{"file":"tmux/option_generated.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClockModeStyle12","product":"core","slug":"tmux-clockmodestyle12"},{"id":"tmux.ClockModeStyle24","name":"ClockModeStyle24","kind":"constant","modifiers":[],"signatures":[],"type":"ClockModeStyle","doc":{"summary":"ClockModeStyle24 selects \"24\"."},"source":{"file":"tmux/option_generated.go","line":96,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClockModeStyle24","product":"core","slug":"tmux-clockmodestyle24"},{"id":"tmux.ClockModeStyle12WithSeconds","name":"ClockModeStyle12WithSeconds","kind":"constant","modifiers":[],"signatures":[],"type":"ClockModeStyle","doc":{"summary":"ClockModeStyle12WithSeconds selects \"12-with-seconds\"."},"source":{"file":"tmux/option_generated.go","line":98,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClockModeStyle12WithSeconds","product":"core","slug":"tmux-clockmodestyle12withseconds"},{"id":"tmux.ClockModeStyle24WithSeconds","name":"ClockModeStyle24WithSeconds","kind":"constant","modifiers":[],"signatures":[],"type":"ClockModeStyle","doc":{"summary":"ClockModeStyle24WithSeconds selects \"24-with-seconds\"."},"source":{"file":"tmux/option_generated.go","line":100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClockModeStyle24WithSeconds","product":"core","slug":"tmux-clockmodestyle24withseconds"},{"id":"tmux.ClockModeStyle.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ClockModeStyle","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClockModeStyle.String","product":"core","slug":"tmux-clockmodestyle-string"},{"id":"tmux.ClockModeStyle.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ClockModeStyle","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":107,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClockModeStyle.Valid","product":"core","slug":"tmux-clockmodestyle-valid"},{"id":"tmux.CopyModeLineNumbers","name":"CopyModeLineNumbers","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CopyModeLineNumbers is a typed value for the \"copy-mode-line-numbers\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":117,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeLineNumbers","product":"core","slug":"tmux-copymodelinenumbers"},{"id":"tmux.CopyModeLineNumbersOff","name":"CopyModeLineNumbersOff","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":121,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeLineNumbersOff","product":"core","slug":"tmux-copymodelinenumbersoff"},{"id":"tmux.CopyModeLineNumbersDefault","name":"CopyModeLineNumbersDefault","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersDefault selects \"default\"."},"source":{"file":"tmux/option_generated.go","line":123,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeLineNumbersDefault","product":"core","slug":"tmux-copymodelinenumbersdefault"},{"id":"tmux.CopyModeLineNumbersAbsolute","name":"CopyModeLineNumbersAbsolute","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersAbsolute selects \"absolute\"."},"source":{"file":"tmux/option_generated.go","line":125,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeLineNumbersAbsolute","product":"core","slug":"tmux-copymodelinenumbersabsolute"},{"id":"tmux.CopyModeLineNumbersRelative","name":"CopyModeLineNumbersRelative","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersRelative selects \"relative\"."},"source":{"file":"tmux/option_generated.go","line":127,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeLineNumbersRelative","product":"core","slug":"tmux-copymodelinenumbersrelative"},{"id":"tmux.CopyModeLineNumbersHybrid","name":"CopyModeLineNumbersHybrid","kind":"constant","modifiers":[],"signatures":[],"type":"CopyModeLineNumbers","doc":{"summary":"CopyModeLineNumbersHybrid selects \"hybrid\"."},"source":{"file":"tmux/option_generated.go","line":129,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeLineNumbersHybrid","product":"core","slug":"tmux-copymodelinenumbershybrid"},{"id":"tmux.CopyModeLineNumbers.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.CopyModeLineNumbers","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":133,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeLineNumbers.String","product":"core","slug":"tmux-copymodelinenumbers-string"},{"id":"tmux.CopyModeLineNumbers.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.CopyModeLineNumbers","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":136,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeLineNumbers.Valid","product":"core","slug":"tmux-copymodelinenumbers-valid"},{"id":"tmux.CursorStyle","name":"CursorStyle","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CursorStyle is a typed value for the \"cursor-style\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":146,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyle","product":"core","slug":"tmux-cursorstyle"},{"id":"tmux.CursorStyleDefault","name":"CursorStyleDefault","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleDefault selects \"default\"."},"source":{"file":"tmux/option_generated.go","line":150,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyleDefault","product":"core","slug":"tmux-cursorstyledefault"},{"id":"tmux.CursorStyleBlinkingBlock","name":"CursorStyleBlinkingBlock","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBlinkingBlock selects \"blinking-block\"."},"source":{"file":"tmux/option_generated.go","line":152,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyleBlinkingBlock","product":"core","slug":"tmux-cursorstyleblinkingblock"},{"id":"tmux.CursorStyleBlock","name":"CursorStyleBlock","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBlock selects \"block\"."},"source":{"file":"tmux/option_generated.go","line":154,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyleBlock","product":"core","slug":"tmux-cursorstyleblock"},{"id":"tmux.CursorStyleBlinkingUnderline","name":"CursorStyleBlinkingUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBlinkingUnderline selects \"blinking-underline\"."},"source":{"file":"tmux/option_generated.go","line":156,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyleBlinkingUnderline","product":"core","slug":"tmux-cursorstyleblinkingunderline"},{"id":"tmux.CursorStyleUnderline","name":"CursorStyleUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleUnderline selects \"underline\"."},"source":{"file":"tmux/option_generated.go","line":158,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyleUnderline","product":"core","slug":"tmux-cursorstyleunderline"},{"id":"tmux.CursorStyleBlinkingBar","name":"CursorStyleBlinkingBar","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBlinkingBar selects \"blinking-bar\"."},"source":{"file":"tmux/option_generated.go","line":160,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyleBlinkingBar","product":"core","slug":"tmux-cursorstyleblinkingbar"},{"id":"tmux.CursorStyleBar","name":"CursorStyleBar","kind":"constant","modifiers":[],"signatures":[],"type":"CursorStyle","doc":{"summary":"CursorStyleBar selects \"bar\"."},"source":{"file":"tmux/option_generated.go","line":162,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyleBar","product":"core","slug":"tmux-cursorstylebar"},{"id":"tmux.CursorStyle.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.CursorStyle","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":166,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyle.String","product":"core","slug":"tmux-cursorstyle-string"},{"id":"tmux.CursorStyle.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.CursorStyle","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":169,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CursorStyle.Valid","product":"core","slug":"tmux-cursorstyle-valid"},{"id":"tmux.DestroyUnattached","name":"DestroyUnattached","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DestroyUnattached is a typed value for the \"destroy-unattached\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":179,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DestroyUnattached","product":"core","slug":"tmux-destroyunattached"},{"id":"tmux.DestroyUnattachedOff","name":"DestroyUnattachedOff","kind":"constant","modifiers":[],"signatures":[],"type":"DestroyUnattached","doc":{"summary":"DestroyUnattachedOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":183,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DestroyUnattachedOff","product":"core","slug":"tmux-destroyunattachedoff"},{"id":"tmux.DestroyUnattachedOn","name":"DestroyUnattachedOn","kind":"constant","modifiers":[],"signatures":[],"type":"DestroyUnattached","doc":{"summary":"DestroyUnattachedOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":185,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DestroyUnattachedOn","product":"core","slug":"tmux-destroyunattachedon"},{"id":"tmux.DestroyUnattachedKeepLast","name":"DestroyUnattachedKeepLast","kind":"constant","modifiers":[],"signatures":[],"type":"DestroyUnattached","doc":{"summary":"DestroyUnattachedKeepLast selects \"keep-last\"."},"source":{"file":"tmux/option_generated.go","line":187,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DestroyUnattachedKeepLast","product":"core","slug":"tmux-destroyunattachedkeeplast"},{"id":"tmux.DestroyUnattachedKeepGroup","name":"DestroyUnattachedKeepGroup","kind":"constant","modifiers":[],"signatures":[],"type":"DestroyUnattached","doc":{"summary":"DestroyUnattachedKeepGroup selects \"keep-group\"."},"source":{"file":"tmux/option_generated.go","line":189,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DestroyUnattachedKeepGroup","product":"core","slug":"tmux-destroyunattachedkeepgroup"},{"id":"tmux.DestroyUnattached.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.DestroyUnattached","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":193,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DestroyUnattached.String","product":"core","slug":"tmux-destroyunattached-string"},{"id":"tmux.DestroyUnattached.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.DestroyUnattached","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":196,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DestroyUnattached.Valid","product":"core","slug":"tmux-destroyunattached-valid"},{"id":"tmux.DetachOnDestroy","name":"DetachOnDestroy","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DetachOnDestroy is a typed value for the \"detach-on-destroy\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":206,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachOnDestroy","product":"core","slug":"tmux-detachondestroy"},{"id":"tmux.DetachOnDestroyOff","name":"DetachOnDestroyOff","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":210,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachOnDestroyOff","product":"core","slug":"tmux-detachondestroyoff"},{"id":"tmux.DetachOnDestroyOn","name":"DetachOnDestroyOn","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":212,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachOnDestroyOn","product":"core","slug":"tmux-detachondestroyon"},{"id":"tmux.DetachOnDestroyNoDetached","name":"DetachOnDestroyNoDetached","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyNoDetached selects \"no-detached\"."},"source":{"file":"tmux/option_generated.go","line":214,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachOnDestroyNoDetached","product":"core","slug":"tmux-detachondestroynodetached"},{"id":"tmux.DetachOnDestroyPrevious","name":"DetachOnDestroyPrevious","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyPrevious selects \"previous\"."},"source":{"file":"tmux/option_generated.go","line":216,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachOnDestroyPrevious","product":"core","slug":"tmux-detachondestroyprevious"},{"id":"tmux.DetachOnDestroyNext","name":"DetachOnDestroyNext","kind":"constant","modifiers":[],"signatures":[],"type":"DetachOnDestroy","doc":{"summary":"DetachOnDestroyNext selects \"next\"."},"source":{"file":"tmux/option_generated.go","line":218,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachOnDestroyNext","product":"core","slug":"tmux-detachondestroynext"},{"id":"tmux.DetachOnDestroy.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.DetachOnDestroy","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":222,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachOnDestroy.String","product":"core","slug":"tmux-detachondestroy-string"},{"id":"tmux.DetachOnDestroy.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.DetachOnDestroy","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":225,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachOnDestroy.Valid","product":"core","slug":"tmux-detachondestroy-valid"},{"id":"tmux.ExtendedKeys","name":"ExtendedKeys","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ExtendedKeys is a typed value for the \"extended-keys\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":235,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeys","product":"core","slug":"tmux-extendedkeys"},{"id":"tmux.ExtendedKeysOff","name":"ExtendedKeysOff","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeys","doc":{"summary":"ExtendedKeysOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":239,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeysOff","product":"core","slug":"tmux-extendedkeysoff"},{"id":"tmux.ExtendedKeysOn","name":"ExtendedKeysOn","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeys","doc":{"summary":"ExtendedKeysOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":241,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeysOn","product":"core","slug":"tmux-extendedkeyson"},{"id":"tmux.ExtendedKeysAlways","name":"ExtendedKeysAlways","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeys","doc":{"summary":"ExtendedKeysAlways selects \"always\"."},"source":{"file":"tmux/option_generated.go","line":243,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeysAlways","product":"core","slug":"tmux-extendedkeysalways"},{"id":"tmux.ExtendedKeys.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ExtendedKeys","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":247,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeys.String","product":"core","slug":"tmux-extendedkeys-string"},{"id":"tmux.ExtendedKeys.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ExtendedKeys","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":250,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeys.Valid","product":"core","slug":"tmux-extendedkeys-valid"},{"id":"tmux.ExtendedKeysFormat","name":"ExtendedKeysFormat","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ExtendedKeysFormat is a typed value for the \"extended-keys-format\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":260,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeysFormat","product":"core","slug":"tmux-extendedkeysformat"},{"id":"tmux.ExtendedKeysFormatCSIU","name":"ExtendedKeysFormatCSIU","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeysFormat","doc":{"summary":"ExtendedKeysFormatCSIU selects \"csi-u\"."},"source":{"file":"tmux/option_generated.go","line":264,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeysFormatCSIU","product":"core","slug":"tmux-extendedkeysformatcsiu"},{"id":"tmux.ExtendedKeysFormatXTerm","name":"ExtendedKeysFormatXTerm","kind":"constant","modifiers":[],"signatures":[],"type":"ExtendedKeysFormat","doc":{"summary":"ExtendedKeysFormatXTerm selects \"xterm\"."},"source":{"file":"tmux/option_generated.go","line":266,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeysFormatXTerm","product":"core","slug":"tmux-extendedkeysformatxterm"},{"id":"tmux.ExtendedKeysFormat.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ExtendedKeysFormat","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":270,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeysFormat.String","product":"core","slug":"tmux-extendedkeysformat-string"},{"id":"tmux.ExtendedKeysFormat.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ExtendedKeysFormat","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":273,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ExtendedKeysFormat.Valid","product":"core","slug":"tmux-extendedkeysformat-valid"},{"id":"tmux.GetClipboard","name":"GetClipboard","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"GetClipboard is a typed value for the \"get-clipboard\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":283,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GetClipboard","product":"core","slug":"tmux-getclipboard"},{"id":"tmux.GetClipboardOff","name":"GetClipboardOff","kind":"constant","modifiers":[],"signatures":[],"type":"GetClipboard","doc":{"summary":"GetClipboardOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":287,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GetClipboardOff","product":"core","slug":"tmux-getclipboardoff"},{"id":"tmux.GetClipboardBuffer","name":"GetClipboardBuffer","kind":"constant","modifiers":[],"signatures":[],"type":"GetClipboard","doc":{"summary":"GetClipboardBuffer selects \"buffer\"."},"source":{"file":"tmux/option_generated.go","line":289,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GetClipboardBuffer","product":"core","slug":"tmux-getclipboardbuffer"},{"id":"tmux.GetClipboardRequest","name":"GetClipboardRequest","kind":"constant","modifiers":[],"signatures":[],"type":"GetClipboard","doc":{"summary":"GetClipboardRequest selects \"request\"."},"source":{"file":"tmux/option_generated.go","line":291,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GetClipboardRequest","product":"core","slug":"tmux-getclipboardrequest"},{"id":"tmux.GetClipboardBoth","name":"GetClipboardBoth","kind":"constant","modifiers":[],"signatures":[],"type":"GetClipboard","doc":{"summary":"GetClipboardBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":293,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GetClipboardBoth","product":"core","slug":"tmux-getclipboardboth"},{"id":"tmux.GetClipboard.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.GetClipboard","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":297,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GetClipboard.String","product":"core","slug":"tmux-getclipboard-string"},{"id":"tmux.GetClipboard.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.GetClipboard","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":300,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GetClipboard.Valid","product":"core","slug":"tmux-getclipboard-valid"},{"id":"tmux.MenuBorderLines","name":"MenuBorderLines","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MenuBorderLines is a typed value for the \"menu-border-lines\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":310,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLines","product":"core","slug":"tmux-menuborderlines"},{"id":"tmux.MenuBorderLinesSingle","name":"MenuBorderLinesSingle","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesSingle selects \"single\"."},"source":{"file":"tmux/option_generated.go","line":314,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLinesSingle","product":"core","slug":"tmux-menuborderlinessingle"},{"id":"tmux.MenuBorderLinesDouble","name":"MenuBorderLinesDouble","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesDouble selects \"double\"."},"source":{"file":"tmux/option_generated.go","line":316,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLinesDouble","product":"core","slug":"tmux-menuborderlinesdouble"},{"id":"tmux.MenuBorderLinesHeavy","name":"MenuBorderLinesHeavy","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesHeavy selects \"heavy\"."},"source":{"file":"tmux/option_generated.go","line":318,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLinesHeavy","product":"core","slug":"tmux-menuborderlinesheavy"},{"id":"tmux.MenuBorderLinesSimple","name":"MenuBorderLinesSimple","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesSimple selects \"simple\"."},"source":{"file":"tmux/option_generated.go","line":320,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLinesSimple","product":"core","slug":"tmux-menuborderlinessimple"},{"id":"tmux.MenuBorderLinesRounded","name":"MenuBorderLinesRounded","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesRounded selects \"rounded\"."},"source":{"file":"tmux/option_generated.go","line":322,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLinesRounded","product":"core","slug":"tmux-menuborderlinesrounded"},{"id":"tmux.MenuBorderLinesPadded","name":"MenuBorderLinesPadded","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesPadded selects \"padded\"."},"source":{"file":"tmux/option_generated.go","line":324,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLinesPadded","product":"core","slug":"tmux-menuborderlinespadded"},{"id":"tmux.MenuBorderLinesNone","name":"MenuBorderLinesNone","kind":"constant","modifiers":[],"signatures":[],"type":"MenuBorderLines","doc":{"summary":"MenuBorderLinesNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":326,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLinesNone","product":"core","slug":"tmux-menuborderlinesnone"},{"id":"tmux.MenuBorderLines.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.MenuBorderLines","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":330,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLines.String","product":"core","slug":"tmux-menuborderlines-string"},{"id":"tmux.MenuBorderLines.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.MenuBorderLines","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":333,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuBorderLines.Valid","product":"core","slug":"tmux-menuborderlines-valid"},{"id":"tmux.MessageLine","name":"MessageLine","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MessageLine is a typed value for the \"message-line\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":343,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MessageLine","product":"core","slug":"tmux-messageline"},{"id":"tmux.MessageLine0","name":"MessageLine0","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine0 selects \"0\"."},"source":{"file":"tmux/option_generated.go","line":347,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MessageLine0","product":"core","slug":"tmux-messageline0"},{"id":"tmux.MessageLine1","name":"MessageLine1","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine1 selects \"1\"."},"source":{"file":"tmux/option_generated.go","line":349,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MessageLine1","product":"core","slug":"tmux-messageline1"},{"id":"tmux.MessageLine2","name":"MessageLine2","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine2 selects \"2\"."},"source":{"file":"tmux/option_generated.go","line":351,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MessageLine2","product":"core","slug":"tmux-messageline2"},{"id":"tmux.MessageLine3","name":"MessageLine3","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine3 selects \"3\"."},"source":{"file":"tmux/option_generated.go","line":353,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MessageLine3","product":"core","slug":"tmux-messageline3"},{"id":"tmux.MessageLine4","name":"MessageLine4","kind":"constant","modifiers":[],"signatures":[],"type":"MessageLine","doc":{"summary":"MessageLine4 selects \"4\"."},"source":{"file":"tmux/option_generated.go","line":355,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MessageLine4","product":"core","slug":"tmux-messageline4"},{"id":"tmux.MessageLine.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.MessageLine","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":359,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MessageLine.String","product":"core","slug":"tmux-messageline-string"},{"id":"tmux.MessageLine.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.MessageLine","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":362,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MessageLine.Valid","product":"core","slug":"tmux-messageline-valid"},{"id":"tmux.ModeKeys","name":"ModeKeys","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ModeKeys is a typed value for the \"mode-keys\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":372,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ModeKeys","product":"core","slug":"tmux-modekeys"},{"id":"tmux.ModeKeysEmacs","name":"ModeKeysEmacs","kind":"constant","modifiers":[],"signatures":[],"type":"ModeKeys","doc":{"summary":"ModeKeysEmacs selects \"emacs\"."},"source":{"file":"tmux/option_generated.go","line":376,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ModeKeysEmacs","product":"core","slug":"tmux-modekeysemacs"},{"id":"tmux.ModeKeysVi","name":"ModeKeysVi","kind":"constant","modifiers":[],"signatures":[],"type":"ModeKeys","doc":{"summary":"ModeKeysVi selects \"vi\"."},"source":{"file":"tmux/option_generated.go","line":378,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ModeKeysVi","product":"core","slug":"tmux-modekeysvi"},{"id":"tmux.ModeKeys.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.ModeKeys","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":382,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ModeKeys.String","product":"core","slug":"tmux-modekeys-string"},{"id":"tmux.ModeKeys.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.ModeKeys","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":385,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ModeKeys.Valid","product":"core","slug":"tmux-modekeys-valid"},{"id":"tmux.PaneBorderIndicators","name":"PaneBorderIndicators","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneBorderIndicators is a typed value for the \"pane-border-indicators\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":395,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderIndicators","product":"core","slug":"tmux-paneborderindicators"},{"id":"tmux.PaneBorderIndicatorsOff","name":"PaneBorderIndicatorsOff","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderIndicators","doc":{"summary":"PaneBorderIndicatorsOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":399,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderIndicatorsOff","product":"core","slug":"tmux-paneborderindicatorsoff"},{"id":"tmux.PaneBorderIndicatorsColour","name":"PaneBorderIndicatorsColour","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderIndicators","doc":{"summary":"PaneBorderIndicatorsColour selects \"colour\"."},"source":{"file":"tmux/option_generated.go","line":401,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderIndicatorsColour","product":"core","slug":"tmux-paneborderindicatorscolour"},{"id":"tmux.PaneBorderIndicatorsArrows","name":"PaneBorderIndicatorsArrows","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderIndicators","doc":{"summary":"PaneBorderIndicatorsArrows selects \"arrows\"."},"source":{"file":"tmux/option_generated.go","line":403,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderIndicatorsArrows","product":"core","slug":"tmux-paneborderindicatorsarrows"},{"id":"tmux.PaneBorderIndicatorsBoth","name":"PaneBorderIndicatorsBoth","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderIndicators","doc":{"summary":"PaneBorderIndicatorsBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":405,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderIndicatorsBoth","product":"core","slug":"tmux-paneborderindicatorsboth"},{"id":"tmux.PaneBorderIndicators.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneBorderIndicators","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":409,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderIndicators.String","product":"core","slug":"tmux-paneborderindicators-string"},{"id":"tmux.PaneBorderIndicators.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneBorderIndicators","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":412,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderIndicators.Valid","product":"core","slug":"tmux-paneborderindicators-valid"},{"id":"tmux.PaneBorderLines","name":"PaneBorderLines","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneBorderLines is a typed value for the \"pane-border-lines\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":422,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLines","product":"core","slug":"tmux-paneborderlines"},{"id":"tmux.PaneBorderLinesSingle","name":"PaneBorderLinesSingle","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesSingle selects \"single\"."},"source":{"file":"tmux/option_generated.go","line":426,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLinesSingle","product":"core","slug":"tmux-paneborderlinessingle"},{"id":"tmux.PaneBorderLinesDouble","name":"PaneBorderLinesDouble","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesDouble selects \"double\"."},"source":{"file":"tmux/option_generated.go","line":428,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLinesDouble","product":"core","slug":"tmux-paneborderlinesdouble"},{"id":"tmux.PaneBorderLinesHeavy","name":"PaneBorderLinesHeavy","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesHeavy selects \"heavy\"."},"source":{"file":"tmux/option_generated.go","line":430,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLinesHeavy","product":"core","slug":"tmux-paneborderlinesheavy"},{"id":"tmux.PaneBorderLinesSimple","name":"PaneBorderLinesSimple","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesSimple selects \"simple\"."},"source":{"file":"tmux/option_generated.go","line":432,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLinesSimple","product":"core","slug":"tmux-paneborderlinessimple"},{"id":"tmux.PaneBorderLinesNumber","name":"PaneBorderLinesNumber","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesNumber selects \"number\"."},"source":{"file":"tmux/option_generated.go","line":434,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLinesNumber","product":"core","slug":"tmux-paneborderlinesnumber"},{"id":"tmux.PaneBorderLinesSpaces","name":"PaneBorderLinesSpaces","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderLines","doc":{"summary":"PaneBorderLinesSpaces selects \"spaces\"."},"source":{"file":"tmux/option_generated.go","line":436,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLinesSpaces","product":"core","slug":"tmux-paneborderlinesspaces"},{"id":"tmux.PaneBorderLines.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneBorderLines","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":440,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLines.String","product":"core","slug":"tmux-paneborderlines-string"},{"id":"tmux.PaneBorderLines.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneBorderLines","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":443,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderLines.Valid","product":"core","slug":"tmux-paneborderlines-valid"},{"id":"tmux.PaneBorderStatus","name":"PaneBorderStatus","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneBorderStatus is a typed value for the \"pane-border-status\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":453,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderStatus","product":"core","slug":"tmux-paneborderstatus"},{"id":"tmux.PaneBorderStatusOff","name":"PaneBorderStatusOff","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderStatus","doc":{"summary":"PaneBorderStatusOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":457,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderStatusOff","product":"core","slug":"tmux-paneborderstatusoff"},{"id":"tmux.PaneBorderStatusTop","name":"PaneBorderStatusTop","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderStatus","doc":{"summary":"PaneBorderStatusTop selects \"top\"."},"source":{"file":"tmux/option_generated.go","line":459,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderStatusTop","product":"core","slug":"tmux-paneborderstatustop"},{"id":"tmux.PaneBorderStatusBottom","name":"PaneBorderStatusBottom","kind":"constant","modifiers":[],"signatures":[],"type":"PaneBorderStatus","doc":{"summary":"PaneBorderStatusBottom selects \"bottom\"."},"source":{"file":"tmux/option_generated.go","line":461,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderStatusBottom","product":"core","slug":"tmux-paneborderstatusbottom"},{"id":"tmux.PaneBorderStatus.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneBorderStatus","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":465,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderStatus.String","product":"core","slug":"tmux-paneborderstatus-string"},{"id":"tmux.PaneBorderStatus.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneBorderStatus","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":468,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneBorderStatus.Valid","product":"core","slug":"tmux-paneborderstatus-valid"},{"id":"tmux.PaneScrollbars","name":"PaneScrollbars","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneScrollbars is a typed value for the \"pane-scrollbars\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":478,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbars","product":"core","slug":"tmux-panescrollbars"},{"id":"tmux.PaneScrollbarsOff","name":"PaneScrollbarsOff","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbars","doc":{"summary":"PaneScrollbarsOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":482,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbarsOff","product":"core","slug":"tmux-panescrollbarsoff"},{"id":"tmux.PaneScrollbarsModal","name":"PaneScrollbarsModal","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbars","doc":{"summary":"PaneScrollbarsModal selects \"modal\"."},"source":{"file":"tmux/option_generated.go","line":484,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbarsModal","product":"core","slug":"tmux-panescrollbarsmodal"},{"id":"tmux.PaneScrollbarsOn","name":"PaneScrollbarsOn","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbars","doc":{"summary":"PaneScrollbarsOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":486,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbarsOn","product":"core","slug":"tmux-panescrollbarson"},{"id":"tmux.PaneScrollbars.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneScrollbars","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":490,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbars.String","product":"core","slug":"tmux-panescrollbars-string"},{"id":"tmux.PaneScrollbars.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneScrollbars","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":493,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbars.Valid","product":"core","slug":"tmux-panescrollbars-valid"},{"id":"tmux.PaneScrollbarsPosition","name":"PaneScrollbarsPosition","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneScrollbarsPosition is a typed value for the \"pane-scrollbars-position\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":503,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbarsPosition","product":"core","slug":"tmux-panescrollbarsposition"},{"id":"tmux.PaneScrollbarsPositionRight","name":"PaneScrollbarsPositionRight","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbarsPosition","doc":{"summary":"PaneScrollbarsPositionRight selects \"right\"."},"source":{"file":"tmux/option_generated.go","line":507,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbarsPositionRight","product":"core","slug":"tmux-panescrollbarspositionright"},{"id":"tmux.PaneScrollbarsPositionLeft","name":"PaneScrollbarsPositionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"PaneScrollbarsPosition","doc":{"summary":"PaneScrollbarsPositionLeft selects \"left\"."},"source":{"file":"tmux/option_generated.go","line":509,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbarsPositionLeft","product":"core","slug":"tmux-panescrollbarspositionleft"},{"id":"tmux.PaneScrollbarsPosition.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PaneScrollbarsPosition","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":513,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbarsPosition.String","product":"core","slug":"tmux-panescrollbarsposition-string"},{"id":"tmux.PaneScrollbarsPosition.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PaneScrollbarsPosition","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":516,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneScrollbarsPosition.Valid","product":"core","slug":"tmux-panescrollbarsposition-valid"},{"id":"tmux.PopupBorderLines","name":"PopupBorderLines","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PopupBorderLines is a typed value for the \"popup-border-lines\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":526,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLines","product":"core","slug":"tmux-popupborderlines"},{"id":"tmux.PopupBorderLinesSingle","name":"PopupBorderLinesSingle","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesSingle selects \"single\"."},"source":{"file":"tmux/option_generated.go","line":530,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLinesSingle","product":"core","slug":"tmux-popupborderlinessingle"},{"id":"tmux.PopupBorderLinesDouble","name":"PopupBorderLinesDouble","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesDouble selects \"double\"."},"source":{"file":"tmux/option_generated.go","line":532,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLinesDouble","product":"core","slug":"tmux-popupborderlinesdouble"},{"id":"tmux.PopupBorderLinesHeavy","name":"PopupBorderLinesHeavy","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesHeavy selects \"heavy\"."},"source":{"file":"tmux/option_generated.go","line":534,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLinesHeavy","product":"core","slug":"tmux-popupborderlinesheavy"},{"id":"tmux.PopupBorderLinesSimple","name":"PopupBorderLinesSimple","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesSimple selects \"simple\"."},"source":{"file":"tmux/option_generated.go","line":536,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLinesSimple","product":"core","slug":"tmux-popupborderlinessimple"},{"id":"tmux.PopupBorderLinesRounded","name":"PopupBorderLinesRounded","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesRounded selects \"rounded\"."},"source":{"file":"tmux/option_generated.go","line":538,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLinesRounded","product":"core","slug":"tmux-popupborderlinesrounded"},{"id":"tmux.PopupBorderLinesPadded","name":"PopupBorderLinesPadded","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesPadded selects \"padded\"."},"source":{"file":"tmux/option_generated.go","line":540,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLinesPadded","product":"core","slug":"tmux-popupborderlinespadded"},{"id":"tmux.PopupBorderLinesNone","name":"PopupBorderLinesNone","kind":"constant","modifiers":[],"signatures":[],"type":"PopupBorderLines","doc":{"summary":"PopupBorderLinesNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":542,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLinesNone","product":"core","slug":"tmux-popupborderlinesnone"},{"id":"tmux.PopupBorderLines.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PopupBorderLines","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":546,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLines.String","product":"core","slug":"tmux-popupborderlines-string"},{"id":"tmux.PopupBorderLines.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PopupBorderLines","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":549,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PopupBorderLines.Valid","product":"core","slug":"tmux-popupborderlines-valid"},{"id":"tmux.PromptCommandCursorStyle","name":"PromptCommandCursorStyle","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PromptCommandCursorStyle is a typed value for the \"prompt-command-cursor-style\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":559,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyle","product":"core","slug":"tmux-promptcommandcursorstyle"},{"id":"tmux.PromptCommandCursorStyleDefault","name":"PromptCommandCursorStyleDefault","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleDefault selects \"default\"."},"source":{"file":"tmux/option_generated.go","line":563,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyleDefault","product":"core","slug":"tmux-promptcommandcursorstyledefault"},{"id":"tmux.PromptCommandCursorStyleBlinkingBlock","name":"PromptCommandCursorStyleBlinkingBlock","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBlinkingBlock selects \"blinking-block\"."},"source":{"file":"tmux/option_generated.go","line":565,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyleBlinkingBlock","product":"core","slug":"tmux-promptcommandcursorstyleblinkingblock"},{"id":"tmux.PromptCommandCursorStyleBlock","name":"PromptCommandCursorStyleBlock","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBlock selects \"block\"."},"source":{"file":"tmux/option_generated.go","line":567,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyleBlock","product":"core","slug":"tmux-promptcommandcursorstyleblock"},{"id":"tmux.PromptCommandCursorStyleBlinkingUnderline","name":"PromptCommandCursorStyleBlinkingUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBlinkingUnderline selects \"blinking-underline\"."},"source":{"file":"tmux/option_generated.go","line":569,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyleBlinkingUnderline","product":"core","slug":"tmux-promptcommandcursorstyleblinkingunderline"},{"id":"tmux.PromptCommandCursorStyleUnderline","name":"PromptCommandCursorStyleUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleUnderline selects \"underline\"."},"source":{"file":"tmux/option_generated.go","line":571,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyleUnderline","product":"core","slug":"tmux-promptcommandcursorstyleunderline"},{"id":"tmux.PromptCommandCursorStyleBlinkingBar","name":"PromptCommandCursorStyleBlinkingBar","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBlinkingBar selects \"blinking-bar\"."},"source":{"file":"tmux/option_generated.go","line":573,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyleBlinkingBar","product":"core","slug":"tmux-promptcommandcursorstyleblinkingbar"},{"id":"tmux.PromptCommandCursorStyleBar","name":"PromptCommandCursorStyleBar","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCommandCursorStyle","doc":{"summary":"PromptCommandCursorStyleBar selects \"bar\"."},"source":{"file":"tmux/option_generated.go","line":575,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyleBar","product":"core","slug":"tmux-promptcommandcursorstylebar"},{"id":"tmux.PromptCommandCursorStyle.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PromptCommandCursorStyle","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":579,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyle.String","product":"core","slug":"tmux-promptcommandcursorstyle-string"},{"id":"tmux.PromptCommandCursorStyle.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PromptCommandCursorStyle","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":582,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCommandCursorStyle.Valid","product":"core","slug":"tmux-promptcommandcursorstyle-valid"},{"id":"tmux.PromptCursorStyle","name":"PromptCursorStyle","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PromptCursorStyle is a typed value for the \"prompt-cursor-style\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":592,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyle","product":"core","slug":"tmux-promptcursorstyle"},{"id":"tmux.PromptCursorStyleDefault","name":"PromptCursorStyleDefault","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleDefault selects \"default\"."},"source":{"file":"tmux/option_generated.go","line":596,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyleDefault","product":"core","slug":"tmux-promptcursorstyledefault"},{"id":"tmux.PromptCursorStyleBlinkingBlock","name":"PromptCursorStyleBlinkingBlock","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBlinkingBlock selects \"blinking-block\"."},"source":{"file":"tmux/option_generated.go","line":598,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyleBlinkingBlock","product":"core","slug":"tmux-promptcursorstyleblinkingblock"},{"id":"tmux.PromptCursorStyleBlock","name":"PromptCursorStyleBlock","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBlock selects \"block\"."},"source":{"file":"tmux/option_generated.go","line":600,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyleBlock","product":"core","slug":"tmux-promptcursorstyleblock"},{"id":"tmux.PromptCursorStyleBlinkingUnderline","name":"PromptCursorStyleBlinkingUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBlinkingUnderline selects \"blinking-underline\"."},"source":{"file":"tmux/option_generated.go","line":602,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyleBlinkingUnderline","product":"core","slug":"tmux-promptcursorstyleblinkingunderline"},{"id":"tmux.PromptCursorStyleUnderline","name":"PromptCursorStyleUnderline","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleUnderline selects \"underline\"."},"source":{"file":"tmux/option_generated.go","line":604,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyleUnderline","product":"core","slug":"tmux-promptcursorstyleunderline"},{"id":"tmux.PromptCursorStyleBlinkingBar","name":"PromptCursorStyleBlinkingBar","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBlinkingBar selects \"blinking-bar\"."},"source":{"file":"tmux/option_generated.go","line":606,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyleBlinkingBar","product":"core","slug":"tmux-promptcursorstyleblinkingbar"},{"id":"tmux.PromptCursorStyleBar","name":"PromptCursorStyleBar","kind":"constant","modifiers":[],"signatures":[],"type":"PromptCursorStyle","doc":{"summary":"PromptCursorStyleBar selects \"bar\"."},"source":{"file":"tmux/option_generated.go","line":608,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyleBar","product":"core","slug":"tmux-promptcursorstylebar"},{"id":"tmux.PromptCursorStyle.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.PromptCursorStyle","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":612,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyle.String","product":"core","slug":"tmux-promptcursorstyle-string"},{"id":"tmux.PromptCursorStyle.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.PromptCursorStyle","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":615,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptCursorStyle.Valid","product":"core","slug":"tmux-promptcursorstyle-valid"},{"id":"tmux.RemainOnExit","name":"RemainOnExit","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RemainOnExit is a typed value for the \"remain-on-exit\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":625,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RemainOnExit","product":"core","slug":"tmux-remainonexit"},{"id":"tmux.RemainOnExitOff","name":"RemainOnExitOff","kind":"constant","modifiers":[],"signatures":[],"type":"RemainOnExit","doc":{"summary":"RemainOnExitOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":629,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RemainOnExitOff","product":"core","slug":"tmux-remainonexitoff"},{"id":"tmux.RemainOnExitOn","name":"RemainOnExitOn","kind":"constant","modifiers":[],"signatures":[],"type":"RemainOnExit","doc":{"summary":"RemainOnExitOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":631,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RemainOnExitOn","product":"core","slug":"tmux-remainonexiton"},{"id":"tmux.RemainOnExitFailed","name":"RemainOnExitFailed","kind":"constant","modifiers":[],"signatures":[],"type":"RemainOnExit","doc":{"summary":"RemainOnExitFailed selects \"failed\"."},"source":{"file":"tmux/option_generated.go","line":633,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RemainOnExitFailed","product":"core","slug":"tmux-remainonexitfailed"},{"id":"tmux.RemainOnExitKey","name":"RemainOnExitKey","kind":"constant","modifiers":[],"signatures":[],"type":"RemainOnExit","doc":{"summary":"RemainOnExitKey selects \"key\"."},"source":{"file":"tmux/option_generated.go","line":635,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RemainOnExitKey","product":"core","slug":"tmux-remainonexitkey"},{"id":"tmux.RemainOnExit.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.RemainOnExit","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":639,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RemainOnExit.String","product":"core","slug":"tmux-remainonexit-string"},{"id":"tmux.RemainOnExit.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.RemainOnExit","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":642,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RemainOnExit.Valid","product":"core","slug":"tmux-remainonexit-valid"},{"id":"tmux.SetClipboard","name":"SetClipboard","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetClipboard is a typed value for the \"set-clipboard\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":652,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetClipboard","product":"core","slug":"tmux-setclipboard"},{"id":"tmux.SetClipboardOff","name":"SetClipboardOff","kind":"constant","modifiers":[],"signatures":[],"type":"SetClipboard","doc":{"summary":"SetClipboardOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":656,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetClipboardOff","product":"core","slug":"tmux-setclipboardoff"},{"id":"tmux.SetClipboardExternal","name":"SetClipboardExternal","kind":"constant","modifiers":[],"signatures":[],"type":"SetClipboard","doc":{"summary":"SetClipboardExternal selects \"external\"."},"source":{"file":"tmux/option_generated.go","line":658,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetClipboardExternal","product":"core","slug":"tmux-setclipboardexternal"},{"id":"tmux.SetClipboardOn","name":"SetClipboardOn","kind":"constant","modifiers":[],"signatures":[],"type":"SetClipboard","doc":{"summary":"SetClipboardOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":660,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetClipboardOn","product":"core","slug":"tmux-setclipboardon"},{"id":"tmux.SetClipboard.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.SetClipboard","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":664,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetClipboard.String","product":"core","slug":"tmux-setclipboard-string"},{"id":"tmux.SetClipboard.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.SetClipboard","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":667,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetClipboard.Valid","product":"core","slug":"tmux-setclipboard-valid"},{"id":"tmux.SilenceAction","name":"SilenceAction","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SilenceAction is a typed value for the \"silence-action\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":677,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SilenceAction","product":"core","slug":"tmux-silenceaction"},{"id":"tmux.SilenceActionNone","name":"SilenceActionNone","kind":"constant","modifiers":[],"signatures":[],"type":"SilenceAction","doc":{"summary":"SilenceActionNone selects \"none\"."},"source":{"file":"tmux/option_generated.go","line":681,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SilenceActionNone","product":"core","slug":"tmux-silenceactionnone"},{"id":"tmux.SilenceActionAny","name":"SilenceActionAny","kind":"constant","modifiers":[],"signatures":[],"type":"SilenceAction","doc":{"summary":"SilenceActionAny selects \"any\"."},"source":{"file":"tmux/option_generated.go","line":683,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SilenceActionAny","product":"core","slug":"tmux-silenceactionany"},{"id":"tmux.SilenceActionCurrent","name":"SilenceActionCurrent","kind":"constant","modifiers":[],"signatures":[],"type":"SilenceAction","doc":{"summary":"SilenceActionCurrent selects \"current\"."},"source":{"file":"tmux/option_generated.go","line":685,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SilenceActionCurrent","product":"core","slug":"tmux-silenceactioncurrent"},{"id":"tmux.SilenceActionOther","name":"SilenceActionOther","kind":"constant","modifiers":[],"signatures":[],"type":"SilenceAction","doc":{"summary":"SilenceActionOther selects \"other\"."},"source":{"file":"tmux/option_generated.go","line":687,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SilenceActionOther","product":"core","slug":"tmux-silenceactionother"},{"id":"tmux.SilenceAction.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.SilenceAction","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":691,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SilenceAction.String","product":"core","slug":"tmux-silenceaction-string"},{"id":"tmux.SilenceAction.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.SilenceAction","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":694,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SilenceAction.Valid","product":"core","slug":"tmux-silenceaction-valid"},{"id":"tmux.Status","name":"Status","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Status is a typed value for the \"status\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":704,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Status","product":"core","slug":"tmux-status"},{"id":"tmux.StatusOff","name":"StatusOff","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"StatusOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":708,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusOff","product":"core","slug":"tmux-statusoff"},{"id":"tmux.StatusOn","name":"StatusOn","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"StatusOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":710,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusOn","product":"core","slug":"tmux-statuson"},{"id":"tmux.Status2","name":"Status2","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"Status2 selects \"2\"."},"source":{"file":"tmux/option_generated.go","line":712,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Status2","product":"core","slug":"tmux-status2"},{"id":"tmux.Status3","name":"Status3","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"Status3 selects \"3\"."},"source":{"file":"tmux/option_generated.go","line":714,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Status3","product":"core","slug":"tmux-status3"},{"id":"tmux.Status4","name":"Status4","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"Status4 selects \"4\"."},"source":{"file":"tmux/option_generated.go","line":716,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Status4","product":"core","slug":"tmux-status4"},{"id":"tmux.Status5","name":"Status5","kind":"constant","modifiers":[],"signatures":[],"type":"Status","doc":{"summary":"Status5 selects \"5\"."},"source":{"file":"tmux/option_generated.go","line":718,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Status5","product":"core","slug":"tmux-status5"},{"id":"tmux.Status.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Status","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":722,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Status.String","product":"core","slug":"tmux-status-string"},{"id":"tmux.Status.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.Status","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":725,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Status.Valid","product":"core","slug":"tmux-status-valid"},{"id":"tmux.StatusJustify","name":"StatusJustify","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"StatusJustify is a typed value for the \"status-justify\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":735,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusJustify","product":"core","slug":"tmux-statusjustify"},{"id":"tmux.StatusJustifyLeft","name":"StatusJustifyLeft","kind":"constant","modifiers":[],"signatures":[],"type":"StatusJustify","doc":{"summary":"StatusJustifyLeft selects \"left\"."},"source":{"file":"tmux/option_generated.go","line":739,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusJustifyLeft","product":"core","slug":"tmux-statusjustifyleft"},{"id":"tmux.StatusJustifyCentre","name":"StatusJustifyCentre","kind":"constant","modifiers":[],"signatures":[],"type":"StatusJustify","doc":{"summary":"StatusJustifyCentre selects \"centre\"."},"source":{"file":"tmux/option_generated.go","line":741,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusJustifyCentre","product":"core","slug":"tmux-statusjustifycentre"},{"id":"tmux.StatusJustifyRight","name":"StatusJustifyRight","kind":"constant","modifiers":[],"signatures":[],"type":"StatusJustify","doc":{"summary":"StatusJustifyRight selects \"right\"."},"source":{"file":"tmux/option_generated.go","line":743,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusJustifyRight","product":"core","slug":"tmux-statusjustifyright"},{"id":"tmux.StatusJustifyAbsoluteCentre","name":"StatusJustifyAbsoluteCentre","kind":"constant","modifiers":[],"signatures":[],"type":"StatusJustify","doc":{"summary":"StatusJustifyAbsoluteCentre selects \"absolute-centre\"."},"source":{"file":"tmux/option_generated.go","line":745,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusJustifyAbsoluteCentre","product":"core","slug":"tmux-statusjustifyabsolutecentre"},{"id":"tmux.StatusJustify.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.StatusJustify","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":749,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusJustify.String","product":"core","slug":"tmux-statusjustify-string"},{"id":"tmux.StatusJustify.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.StatusJustify","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":752,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusJustify.Valid","product":"core","slug":"tmux-statusjustify-valid"},{"id":"tmux.StatusKeys","name":"StatusKeys","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"StatusKeys is a typed value for the \"status-keys\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":762,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusKeys","product":"core","slug":"tmux-statuskeys"},{"id":"tmux.StatusKeysEmacs","name":"StatusKeysEmacs","kind":"constant","modifiers":[],"signatures":[],"type":"StatusKeys","doc":{"summary":"StatusKeysEmacs selects \"emacs\"."},"source":{"file":"tmux/option_generated.go","line":766,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusKeysEmacs","product":"core","slug":"tmux-statuskeysemacs"},{"id":"tmux.StatusKeysVi","name":"StatusKeysVi","kind":"constant","modifiers":[],"signatures":[],"type":"StatusKeys","doc":{"summary":"StatusKeysVi selects \"vi\"."},"source":{"file":"tmux/option_generated.go","line":768,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusKeysVi","product":"core","slug":"tmux-statuskeysvi"},{"id":"tmux.StatusKeys.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.StatusKeys","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":772,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusKeys.String","product":"core","slug":"tmux-statuskeys-string"},{"id":"tmux.StatusKeys.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.StatusKeys","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":775,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusKeys.Valid","product":"core","slug":"tmux-statuskeys-valid"},{"id":"tmux.StatusPosition","name":"StatusPosition","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"StatusPosition is a typed value for the \"status-position\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":785,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusPosition","product":"core","slug":"tmux-statusposition"},{"id":"tmux.StatusPositionTop","name":"StatusPositionTop","kind":"constant","modifiers":[],"signatures":[],"type":"StatusPosition","doc":{"summary":"StatusPositionTop selects \"top\"."},"source":{"file":"tmux/option_generated.go","line":789,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusPositionTop","product":"core","slug":"tmux-statuspositiontop"},{"id":"tmux.StatusPositionBottom","name":"StatusPositionBottom","kind":"constant","modifiers":[],"signatures":[],"type":"StatusPosition","doc":{"summary":"StatusPositionBottom selects \"bottom\"."},"source":{"file":"tmux/option_generated.go","line":791,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusPositionBottom","product":"core","slug":"tmux-statuspositionbottom"},{"id":"tmux.StatusPosition.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.StatusPosition","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":795,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusPosition.String","product":"core","slug":"tmux-statusposition-string"},{"id":"tmux.StatusPosition.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.StatusPosition","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":798,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.StatusPosition.Valid","product":"core","slug":"tmux-statusposition-valid"},{"id":"tmux.VisualActivity","name":"VisualActivity","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VisualActivity is a typed value for the \"visual-activity\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":808,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualActivity","product":"core","slug":"tmux-visualactivity"},{"id":"tmux.VisualActivityOff","name":"VisualActivityOff","kind":"constant","modifiers":[],"signatures":[],"type":"VisualActivity","doc":{"summary":"VisualActivityOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":812,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualActivityOff","product":"core","slug":"tmux-visualactivityoff"},{"id":"tmux.VisualActivityOn","name":"VisualActivityOn","kind":"constant","modifiers":[],"signatures":[],"type":"VisualActivity","doc":{"summary":"VisualActivityOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":814,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualActivityOn","product":"core","slug":"tmux-visualactivityon"},{"id":"tmux.VisualActivityBoth","name":"VisualActivityBoth","kind":"constant","modifiers":[],"signatures":[],"type":"VisualActivity","doc":{"summary":"VisualActivityBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":816,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualActivityBoth","product":"core","slug":"tmux-visualactivityboth"},{"id":"tmux.VisualActivity.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.VisualActivity","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":820,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualActivity.String","product":"core","slug":"tmux-visualactivity-string"},{"id":"tmux.VisualActivity.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.VisualActivity","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":823,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualActivity.Valid","product":"core","slug":"tmux-visualactivity-valid"},{"id":"tmux.VisualBell","name":"VisualBell","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VisualBell is a typed value for the \"visual-bell\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":833,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualBell","product":"core","slug":"tmux-visualbell"},{"id":"tmux.VisualBellOff","name":"VisualBellOff","kind":"constant","modifiers":[],"signatures":[],"type":"VisualBell","doc":{"summary":"VisualBellOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":837,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualBellOff","product":"core","slug":"tmux-visualbelloff"},{"id":"tmux.VisualBellOn","name":"VisualBellOn","kind":"constant","modifiers":[],"signatures":[],"type":"VisualBell","doc":{"summary":"VisualBellOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":839,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualBellOn","product":"core","slug":"tmux-visualbellon"},{"id":"tmux.VisualBellBoth","name":"VisualBellBoth","kind":"constant","modifiers":[],"signatures":[],"type":"VisualBell","doc":{"summary":"VisualBellBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":841,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualBellBoth","product":"core","slug":"tmux-visualbellboth"},{"id":"tmux.VisualBell.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.VisualBell","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":845,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualBell.String","product":"core","slug":"tmux-visualbell-string"},{"id":"tmux.VisualBell.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.VisualBell","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":848,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualBell.Valid","product":"core","slug":"tmux-visualbell-valid"},{"id":"tmux.VisualSilence","name":"VisualSilence","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VisualSilence is a typed value for the \"visual-silence\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":858,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualSilence","product":"core","slug":"tmux-visualsilence"},{"id":"tmux.VisualSilenceOff","name":"VisualSilenceOff","kind":"constant","modifiers":[],"signatures":[],"type":"VisualSilence","doc":{"summary":"VisualSilenceOff selects \"off\"."},"source":{"file":"tmux/option_generated.go","line":862,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualSilenceOff","product":"core","slug":"tmux-visualsilenceoff"},{"id":"tmux.VisualSilenceOn","name":"VisualSilenceOn","kind":"constant","modifiers":[],"signatures":[],"type":"VisualSilence","doc":{"summary":"VisualSilenceOn selects \"on\"."},"source":{"file":"tmux/option_generated.go","line":864,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualSilenceOn","product":"core","slug":"tmux-visualsilenceon"},{"id":"tmux.VisualSilenceBoth","name":"VisualSilenceBoth","kind":"constant","modifiers":[],"signatures":[],"type":"VisualSilence","doc":{"summary":"VisualSilenceBoth selects \"both\"."},"source":{"file":"tmux/option_generated.go","line":866,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualSilenceBoth","product":"core","slug":"tmux-visualsilenceboth"},{"id":"tmux.VisualSilence.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.VisualSilence","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":870,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualSilence.String","product":"core","slug":"tmux-visualsilence-string"},{"id":"tmux.VisualSilence.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.VisualSilence","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":873,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VisualSilence.Valid","product":"core","slug":"tmux-visualsilence-valid"},{"id":"tmux.WindowSize","name":"WindowSize","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowSize is a typed value for the \"window-size\" tmux option. Its zero value is invalid."},"source":{"file":"tmux/option_generated.go","line":883,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSize","product":"core","slug":"tmux-windowsize"},{"id":"tmux.WindowSizeLargest","name":"WindowSizeLargest","kind":"constant","modifiers":[],"signatures":[],"type":"WindowSize","doc":{"summary":"WindowSizeLargest selects \"largest\"."},"source":{"file":"tmux/option_generated.go","line":887,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSizeLargest","product":"core","slug":"tmux-windowsizelargest"},{"id":"tmux.WindowSizeSmallest","name":"WindowSizeSmallest","kind":"constant","modifiers":[],"signatures":[],"type":"WindowSize","doc":{"summary":"WindowSizeSmallest selects \"smallest\"."},"source":{"file":"tmux/option_generated.go","line":889,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSizeSmallest","product":"core","slug":"tmux-windowsizesmallest"},{"id":"tmux.WindowSizeManual","name":"WindowSizeManual","kind":"constant","modifiers":[],"signatures":[],"type":"WindowSize","doc":{"summary":"WindowSizeManual selects \"manual\"."},"source":{"file":"tmux/option_generated.go","line":891,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSizeManual","product":"core","slug":"tmux-windowsizemanual"},{"id":"tmux.WindowSizeLatest","name":"WindowSizeLatest","kind":"constant","modifiers":[],"signatures":[],"type":"WindowSize","doc":{"summary":"WindowSizeLatest selects \"latest\"."},"source":{"file":"tmux/option_generated.go","line":893,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSizeLatest","product":"core","slug":"tmux-windowsizelatest"},{"id":"tmux.WindowSize.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.WindowSize","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the exact tmux spelling of v."},"source":{"file":"tmux/option_generated.go","line":897,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSize.String","product":"core","slug":"tmux-windowsize-string"},{"id":"tmux.WindowSize.Valid","name":"Valid","kind":"method","modifiers":[],"parent":"tmux.WindowSize","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Valid reports whether v belongs to the supported tmux-version union."},"source":{"file":"tmux/option_generated.go","line":900,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSize.Valid","product":"core","slug":"tmux-windowsize-valid"},{"id":"tmux.ControlNotificationKind","name":"ControlNotificationKind","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlNotificationKind identifies a tmux control-mode notification record. Its zero value is unknown and is not emitted by tmux. [ParseControlNotification] returns known values for the pinned wire vocabulary and rejects unknown notification records."},"source":{"file":"tmux/option_generated.go","line":963,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationKind","product":"core","slug":"tmux-controlnotificationkind"},{"id":"tmux.ControlNotificationClientDetached","name":"ControlNotificationClientDetached","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationClientDetached identifies the %client-detached notification, available since tmux 3.2a. Its wire grammar is %client-detached <client>. ParseControlNotification returns its arguments as client tail."},"source":{"file":"tmux/option_generated.go","line":1683,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationClientDetached","product":"core","slug":"tmux-controlnotificationclientdetached"},{"id":"tmux.ControlNotificationClientSessionChanged","name":"ControlNotificationClientSessionChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationClientSessionChanged identifies the %client-session-changed notification, available since tmux 3.2a. Its wire grammar is %client-session-changed <client> <session ID> <session name>. ParseControlNotification returns its arguments as client, session ID, session name tail."},"source":{"file":"tmux/option_generated.go","line":1686,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationClientSessionChanged","product":"core","slug":"tmux-controlnotificationclientsessionchanged"},{"id":"tmux.ControlNotificationConfigError","name":"ControlNotificationConfigError","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationConfigError identifies the %config-error notification, available since tmux 3.4. Its wire grammar is %config-error <text>. ParseControlNotification returns its arguments as text tail."},"source":{"file":"tmux/option_generated.go","line":1689,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationConfigError","product":"core","slug":"tmux-controlnotificationconfigerror"},{"id":"tmux.ControlNotificationContinue","name":"ControlNotificationContinue","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationContinue identifies the %continue notification, available since tmux 3.2a. Its wire grammar is %continue <pane ID>. ParseControlNotification returns its arguments as pane ID."},"source":{"file":"tmux/option_generated.go","line":1692,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationContinue","product":"core","slug":"tmux-controlnotificationcontinue"},{"id":"tmux.ControlNotificationExit","name":"ControlNotificationExit","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationExit identifies the %exit notification, available since tmux 3.2a. Its wire grammar is %exit or %exit <reason>. ParseControlNotification returns its arguments as reason tail."},"source":{"file":"tmux/option_generated.go","line":1695,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationExit","product":"core","slug":"tmux-controlnotificationexit"},{"id":"tmux.ControlNotificationExtendedOutput","name":"ControlNotificationExtendedOutput","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationExtendedOutput identifies the %extended-output notification, available since tmux 3.2a. Its wire grammar is %extended-output <pane ID> <age> { zero or more <reserved argument> } : <data>. ParseControlNotification returns its arguments as the prefix arguments, then zero or more reserved arguments, then the data tail; the prefix arguments are pane ID, age. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1699,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationExtendedOutput","product":"core","slug":"tmux-controlnotificationextendedoutput"},{"id":"tmux.ControlNotificationLayoutChange","name":"ControlNotificationLayoutChange","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationLayoutChange identifies the %layout-change notification, available since tmux 3.2a. Its wire grammar is %layout-change <window ID> <layout> <visible layout> <flags>. ParseControlNotification returns its arguments as window ID, layout, visible layout, flags tail. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1703,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationLayoutChange","product":"core","slug":"tmux-controlnotificationlayoutchange"},{"id":"tmux.ControlNotificationMessage","name":"ControlNotificationMessage","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationMessage identifies the %message notification, available since tmux 3.4. Its wire grammar is %message <text>. ParseControlNotification returns its arguments as text tail. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1707,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationMessage","product":"core","slug":"tmux-controlnotificationmessage"},{"id":"tmux.ControlNotificationOutput","name":"ControlNotificationOutput","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationOutput identifies the %output notification, available since tmux 3.2a. Its wire grammar is %output <pane ID> <data>. ParseControlNotification returns its arguments as pane ID, data tail. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1711,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationOutput","product":"core","slug":"tmux-controlnotificationoutput"},{"id":"tmux.ControlNotificationPaneModeChanged","name":"ControlNotificationPaneModeChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationPaneModeChanged identifies the %pane-mode-changed notification, available since tmux 3.2a. Its wire grammar is %pane-mode-changed <pane ID>. ParseControlNotification returns its arguments as pane ID."},"source":{"file":"tmux/option_generated.go","line":1714,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationPaneModeChanged","product":"core","slug":"tmux-controlnotificationpanemodechanged"},{"id":"tmux.ControlNotificationPasteBufferChanged","name":"ControlNotificationPasteBufferChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationPasteBufferChanged identifies the %paste-buffer-changed notification, available since tmux 3.4. Its wire grammar is %paste-buffer-changed <name>. ParseControlNotification returns its arguments as name tail."},"source":{"file":"tmux/option_generated.go","line":1717,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationPasteBufferChanged","product":"core","slug":"tmux-controlnotificationpastebufferchanged"},{"id":"tmux.ControlNotificationPasteBufferDeleted","name":"ControlNotificationPasteBufferDeleted","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationPasteBufferDeleted identifies the %paste-buffer-deleted notification, available since tmux 3.4. Its wire grammar is %paste-buffer-deleted <name>. ParseControlNotification returns its arguments as name tail."},"source":{"file":"tmux/option_generated.go","line":1720,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationPasteBufferDeleted","product":"core","slug":"tmux-controlnotificationpastebufferdeleted"},{"id":"tmux.ControlNotificationPause","name":"ControlNotificationPause","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationPause identifies the %pause notification, available since tmux 3.2a. Its wire grammar is %pause <pane ID>. ParseControlNotification returns its arguments as pane ID."},"source":{"file":"tmux/option_generated.go","line":1723,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationPause","product":"core","slug":"tmux-controlnotificationpause"},{"id":"tmux.ControlNotificationSessionChanged","name":"ControlNotificationSessionChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSessionChanged identifies the %session-changed notification, available since tmux 3.2a. Its wire grammar is %session-changed <session ID> <session name>. ParseControlNotification returns its arguments as session ID, session name tail."},"source":{"file":"tmux/option_generated.go","line":1726,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationSessionChanged","product":"core","slug":"tmux-controlnotificationsessionchanged"},{"id":"tmux.ControlNotificationSessionRenamed","name":"ControlNotificationSessionRenamed","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSessionRenamed identifies the %session-renamed notification, available since tmux 3.2a. Its wire grammar is %session-renamed <session ID> <session name>. ParseControlNotification returns its arguments as session ID, session name tail."},"source":{"file":"tmux/option_generated.go","line":1729,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationSessionRenamed","product":"core","slug":"tmux-controlnotificationsessionrenamed"},{"id":"tmux.ControlNotificationSessionWindowChanged","name":"ControlNotificationSessionWindowChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSessionWindowChanged identifies the %session-window-changed notification, available since tmux 3.2a. Its wire grammar is %session-window-changed <session ID> <window ID>. ParseControlNotification returns its arguments as session ID, window ID."},"source":{"file":"tmux/option_generated.go","line":1732,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationSessionWindowChanged","product":"core","slug":"tmux-controlnotificationsessionwindowchanged"},{"id":"tmux.ControlNotificationSessionsChanged","name":"ControlNotificationSessionsChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSessionsChanged identifies the %sessions-changed notification, available since tmux 3.2a. Its wire grammar is %sessions-changed. ParseControlNotification returns its arguments as no arguments."},"source":{"file":"tmux/option_generated.go","line":1735,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationSessionsChanged","product":"core","slug":"tmux-controlnotificationsessionschanged"},{"id":"tmux.ControlNotificationSubscriptionChanged","name":"ControlNotificationSubscriptionChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationSubscriptionChanged identifies the %subscription-changed notification, available since tmux 3.2a. Its wire grammar is %subscription-changed <name> <session ID> <window ID> <window index> <pane ID> { zero or more <reserved argument> } : <value>. ParseControlNotification returns its arguments as the prefix arguments, then zero or more reserved arguments, then the value tail; the prefix arguments are name, session ID, window ID, window index, pane ID. Its tail may be empty."},"source":{"file":"tmux/option_generated.go","line":1739,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationSubscriptionChanged","product":"core","slug":"tmux-controlnotificationsubscriptionchanged"},{"id":"tmux.ControlNotificationUnlinkedWindowAdd","name":"ControlNotificationUnlinkedWindowAdd","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationUnlinkedWindowAdd identifies the %unlinked-window-add notification, available since tmux 3.2a. Its wire grammar is %unlinked-window-add <window ID>. ParseControlNotification returns its arguments as window ID."},"source":{"file":"tmux/option_generated.go","line":1742,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationUnlinkedWindowAdd","product":"core","slug":"tmux-controlnotificationunlinkedwindowadd"},{"id":"tmux.ControlNotificationUnlinkedWindowClose","name":"ControlNotificationUnlinkedWindowClose","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationUnlinkedWindowClose identifies the %unlinked-window-close notification, available since tmux 3.2a. Its wire grammar is %unlinked-window-close <window ID>. ParseControlNotification returns its arguments as window ID."},"source":{"file":"tmux/option_generated.go","line":1745,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationUnlinkedWindowClose","product":"core","slug":"tmux-controlnotificationunlinkedwindowclose"},{"id":"tmux.ControlNotificationUnlinkedWindowRenamed","name":"ControlNotificationUnlinkedWindowRenamed","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationUnlinkedWindowRenamed identifies the %unlinked-window-renamed notification, available since tmux 3.2a. Its wire grammar is %unlinked-window-renamed <window ID> <name>. ParseControlNotification returns its arguments as window ID, name tail."},"source":{"file":"tmux/option_generated.go","line":1748,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationUnlinkedWindowRenamed","product":"core","slug":"tmux-controlnotificationunlinkedwindowrenamed"},{"id":"tmux.ControlNotificationWindowAdd","name":"ControlNotificationWindowAdd","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationWindowAdd identifies the %window-add notification, available since tmux 3.2a. Its wire grammar is %window-add <window ID>. ParseControlNotification returns its arguments as window ID."},"source":{"file":"tmux/option_generated.go","line":1751,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationWindowAdd","product":"core","slug":"tmux-controlnotificationwindowadd"},{"id":"tmux.ControlNotificationWindowClose","name":"ControlNotificationWindowClose","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationWindowClose identifies the %window-close notification, available since tmux 3.2a. Its wire grammar is %window-close <window ID>. ParseControlNotification returns its arguments as window ID."},"source":{"file":"tmux/option_generated.go","line":1754,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationWindowClose","product":"core","slug":"tmux-controlnotificationwindowclose"},{"id":"tmux.ControlNotificationWindowPaneChanged","name":"ControlNotificationWindowPaneChanged","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationWindowPaneChanged identifies the %window-pane-changed notification, available since tmux 3.2a. Its wire grammar is %window-pane-changed <window ID> <pane ID>. ParseControlNotification returns its arguments as window ID, pane ID."},"source":{"file":"tmux/option_generated.go","line":1757,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationWindowPaneChanged","product":"core","slug":"tmux-controlnotificationwindowpanechanged"},{"id":"tmux.ControlNotificationWindowRenamed","name":"ControlNotificationWindowRenamed","kind":"constant","modifiers":[],"signatures":[],"type":"ControlNotificationKind","doc":{"summary":"ControlNotificationWindowRenamed identifies the %window-renamed notification, available since tmux 3.2a. Its wire grammar is %window-renamed <window ID> <name>. ParseControlNotification returns its arguments as window ID, name tail."},"source":{"file":"tmux/option_generated.go","line":1760,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationWindowRenamed","product":"core","slug":"tmux-controlnotificationwindowrenamed"},{"id":"tmux.ControlNotificationKind.MinimumVersion","name":"MinimumVersion","kind":"method","modifiers":[],"parent":"tmux.ControlNotificationKind","signatures":[{"params":[],"returns":"(Version, bool)"}],"doc":{"summary":"MinimumVersion returns the oldest [Version] that emits k. It returns ok == false for the zero value and unknown kinds."},"source":{"file":"tmux/option_generated.go","line":1793,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ControlNotificationKind.MinimumVersion","product":"core","slug":"tmux-controlnotificationkind-minimumversion"},{"id":"tmux.ServerOptionValues","name":"ServerOptionValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerOptionValues is an immutable materialized view of known server option values; its zero value is empty and it does not refresh. Obtain it with [Server.Options]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Server.RawOption] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":1816,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues","product":"core","slug":"tmux-serveroptionvalues"},{"id":"tmux.ServerOptionValues.Backspace","name":"Backspace","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"Backspace returns materialized \"backspace\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as KEY since tmux 3.2a; set it with [Server.SetBackspace]."},"source":{"file":"tmux/option_generated.go","line":1846,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.Backspace","product":"core","slug":"tmux-serveroptionvalues-backspace"},{"id":"tmux.ServerOptionValues.BufferLimit","name":"BufferLimit","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"BufferLimit returns materialized \"buffer-limit\" as [OptionValue] with value type OptionValue[int64] from server option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Server.SetBufferLimit]."},"source":{"file":"tmux/option_generated.go","line":1850,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.BufferLimit","product":"core","slug":"tmux-serveroptionvalues-bufferlimit"},{"id":"tmux.ServerOptionValues.CodepointWidths","name":"CodepointWidths","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"CodepointWidths returns materialized \"codepoint-widths\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Server.SetCodepointWidths]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1855,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.CodepointWidths","product":"core","slug":"tmux-serveroptionvalues-codepointwidths"},{"id":"tmux.ServerOptionValues.CommandAlias","name":"CommandAlias","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"CommandAlias returns materialized \"command-alias\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetCommandAlias]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1862,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.CommandAlias","product":"core","slug":"tmux-serveroptionvalues-commandalias"},{"id":"tmux.ServerOptionValues.CopyCommand","name":"CopyCommand","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyCommand returns materialized \"copy-command\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetCopyCommand]."},"source":{"file":"tmux/option_generated.go","line":1866,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.CopyCommand","product":"core","slug":"tmux-serveroptionvalues-copycommand"},{"id":"tmux.ServerOptionValues.DefaultClientCommand","name":"DefaultClientCommand","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultClientCommand returns materialized \"default-client-command\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as COMMAND since tmux 3.6; set it with [Server.SetDefaultClientCommand]."},"source":{"file":"tmux/option_generated.go","line":1870,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.DefaultClientCommand","product":"core","slug":"tmux-serveroptionvalues-defaultclientcommand"},{"id":"tmux.ServerOptionValues.DefaultTerminal","name":"DefaultTerminal","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultTerminal returns materialized \"default-terminal\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetDefaultTerminal]."},"source":{"file":"tmux/option_generated.go","line":1874,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.DefaultTerminal","product":"core","slug":"tmux-serveroptionvalues-defaultterminal"},{"id":"tmux.ServerOptionValues.Editor","name":"Editor","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"Editor returns materialized \"editor\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetEditor]."},"source":{"file":"tmux/option_generated.go","line":1878,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.Editor","product":"core","slug":"tmux-serveroptionvalues-editor"},{"id":"tmux.ServerOptionValues.EscapeTime","name":"EscapeTime","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"EscapeTime returns materialized \"escape-time\" as [OptionValue] with value type OptionValue[time.Duration] from server option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Server.SetEscapeTime]."},"source":{"file":"tmux/option_generated.go","line":1882,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.EscapeTime","product":"core","slug":"tmux-serveroptionvalues-escapetime"},{"id":"tmux.ServerOptionValues.ExitEmpty","name":"ExitEmpty","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"ExitEmpty returns materialized \"exit-empty\" as [OptionValue] with value type OptionValue[bool] from server option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Server.SetExitEmpty]."},"source":{"file":"tmux/option_generated.go","line":1886,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.ExitEmpty","product":"core","slug":"tmux-serveroptionvalues-exitempty"},{"id":"tmux.ServerOptionValues.ExitUnattached","name":"ExitUnattached","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"ExitUnattached returns materialized \"exit-unattached\" as [OptionValue] with value type OptionValue[bool] from server option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Server.SetExitUnattached]."},"source":{"file":"tmux/option_generated.go","line":1890,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.ExitUnattached","product":"core","slug":"tmux-serveroptionvalues-exitunattached"},{"id":"tmux.ServerOptionValues.ExtendedKeys","name":"ExtendedKeys","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[ExtendedKeys]"}],"doc":{"summary":"ExtendedKeys returns materialized \"extended-keys\" as [OptionValue] with value type OptionValue[ExtendedKeys] from server option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"always\"); set it with [Server.SetExtendedKeys]."},"source":{"file":"tmux/option_generated.go","line":1894,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.ExtendedKeys","product":"core","slug":"tmux-serveroptionvalues-extendedkeys"},{"id":"tmux.ServerOptionValues.ExtendedKeysFormat","name":"ExtendedKeysFormat","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[ExtendedKeysFormat]"}],"doc":{"summary":"ExtendedKeysFormat returns materialized \"extended-keys-format\" as [OptionValue] with value type OptionValue[ExtendedKeysFormat] from server option values; it does not query tmux. Available as CHOICE since tmux 3.5 (choices: \"csi-u\", \"xterm\"); set it with [Server.SetExtendedKeysFormat]."},"source":{"file":"tmux/option_generated.go","line":1898,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.ExtendedKeysFormat","product":"core","slug":"tmux-serveroptionvalues-extendedkeysformat"},{"id":"tmux.ServerOptionValues.FocusEvents","name":"FocusEvents","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"FocusEvents returns materialized \"focus-events\" as [OptionValue] with value type OptionValue[bool] from server option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Server.SetFocusEvents]."},"source":{"file":"tmux/option_generated.go","line":1904,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.FocusEvents","product":"core","slug":"tmux-serveroptionvalues-focusevents"},{"id":"tmux.ServerOptionValues.GetClipboard","name":"GetClipboard","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[GetClipboard]"}],"doc":{"summary":"GetClipboard returns materialized \"get-clipboard\" as [OptionValue] with value type OptionValue[GetClipboard] from server option values; it does not query tmux. Available as CHOICE since tmux 3.7 (choices: \"off\", \"buffer\", \"request\", \"both\"); set it with [Server.SetGetClipboard]."},"source":{"file":"tmux/option_generated.go","line":1908,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.GetClipboard","product":"core","slug":"tmux-serveroptionvalues-getclipboard"},{"id":"tmux.ServerOptionValues.HistoryFile","name":"HistoryFile","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"HistoryFile returns materialized \"history-file\" as [OptionValue] with value type OptionValue[string] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetHistoryFile]."},"source":{"file":"tmux/option_generated.go","line":1912,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.HistoryFile","product":"core","slug":"tmux-serveroptionvalues-historyfile"},{"id":"tmux.ServerOptionValues.InputBufferSize","name":"InputBufferSize","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"InputBufferSize returns materialized \"input-buffer-size\" as [OptionValue] with value type OptionValue[int64] from server option values; it does not query tmux. Available as NUMBER since tmux 3.6; set it with [Server.SetInputBufferSize]."},"source":{"file":"tmux/option_generated.go","line":1916,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.InputBufferSize","product":"core","slug":"tmux-serveroptionvalues-inputbuffersize"},{"id":"tmux.ServerOptionValues.MessageLimit","name":"MessageLimit","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"MessageLimit returns materialized \"message-limit\" as [OptionValue] with value type OptionValue[int64] from server option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Server.SetMessageLimit]."},"source":{"file":"tmux/option_generated.go","line":1920,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.MessageLimit","product":"core","slug":"tmux-serveroptionvalues-messagelimit"},{"id":"tmux.ServerOptionValues.PrefixTimeout","name":"PrefixTimeout","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"PrefixTimeout returns materialized \"prefix-timeout\" as [OptionValue] with value type OptionValue[time.Duration] from server option values; it does not query tmux. Available as NUMBER since tmux 3.5; set it with [Server.SetPrefixTimeout]."},"source":{"file":"tmux/option_generated.go","line":1924,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.PrefixTimeout","product":"core","slug":"tmux-serveroptionvalues-prefixtimeout"},{"id":"tmux.ServerOptionValues.PromptHistoryLimit","name":"PromptHistoryLimit","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"PromptHistoryLimit returns materialized \"prompt-history-limit\" as [OptionValue] with value type OptionValue[int64] from server option values; it does not query tmux. Available as NUMBER since tmux 3.3; set it with [Server.SetPromptHistoryLimit]."},"source":{"file":"tmux/option_generated.go","line":1928,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.PromptHistoryLimit","product":"core","slug":"tmux-serveroptionvalues-prompthistorylimit"},{"id":"tmux.ServerOptionValues.SetClipboard","name":"SetClipboard","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SetClipboard]"}],"doc":{"summary":"SetClipboard returns materialized \"set-clipboard\" as [OptionValue] with value type OptionValue[SetClipboard] from server option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"external\", \"on\"); set it with [Server.SetClipboard]."},"source":{"file":"tmux/option_generated.go","line":1932,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.SetClipboard","product":"core","slug":"tmux-serveroptionvalues-setclipboard"},{"id":"tmux.ServerOptionValues.TerminalFeatures","name":"TerminalFeatures","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"TerminalFeatures returns materialized \"terminal-features\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetTerminalFeatures]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1937,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.TerminalFeatures","product":"core","slug":"tmux-serveroptionvalues-terminalfeatures"},{"id":"tmux.ServerOptionValues.TerminalOverrides","name":"TerminalOverrides","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"TerminalOverrides returns materialized \"terminal-overrides\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetTerminalOverrides]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1944,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.TerminalOverrides","product":"core","slug":"tmux-serveroptionvalues-terminaloverrides"},{"id":"tmux.ServerOptionValues.UserKeys","name":"UserKeys","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"UserKeys returns materialized \"user-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from server option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Server.SetUserKeys]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":1951,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.UserKeys","product":"core","slug":"tmux-serveroptionvalues-userkeys"},{"id":"tmux.ServerOptionValues.VariationSelectorAlwaysWide","name":"VariationSelectorAlwaysWide","kind":"method","modifiers":[],"parent":"tmux.ServerOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"VariationSelectorAlwaysWide returns materialized \"variation-selector-always-wide\" as [OptionValue] with value type OptionValue[bool] from server option values; it does not query tmux. Available as FLAG since tmux 3.6; set it with [Server.SetVariationSelectorAlwaysWide]."},"source":{"file":"tmux/option_generated.go","line":1955,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptionValues.VariationSelectorAlwaysWide","product":"core","slug":"tmux-serveroptionvalues-variationselectoralwayswide"},{"id":"tmux.SessionOptionValues","name":"SessionOptionValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionOptionValues is an immutable materialized view of known session option values; its zero value is empty and it does not refresh. Obtain it with [Session.Options] or [GlobalSessionScope.Options]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Session.RawOption] or [GlobalSessionScope.RawOption] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":2021,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues","product":"core","slug":"tmux-sessionoptionvalues"},{"id":"tmux.SessionOptionValues.ActivityAction","name":"ActivityAction","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[ActivityAction]"}],"doc":{"summary":"ActivityAction returns materialized \"activity-action\" as [OptionValue] with value type OptionValue[ActivityAction] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"none\", \"any\", \"current\", \"other\"); set it with [Session.SetActivityAction] or [GlobalSessionScope.SetActivityAction]."},"source":{"file":"tmux/option_generated.go","line":2080,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.ActivityAction","product":"core","slug":"tmux-sessionoptionvalues-activityaction"},{"id":"tmux.SessionOptionValues.AssumePasteTime","name":"AssumePasteTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"AssumePasteTime returns materialized \"assume-paste-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetAssumePasteTime] or [GlobalSessionScope.SetAssumePasteTime]."},"source":{"file":"tmux/option_generated.go","line":2084,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.AssumePasteTime","product":"core","slug":"tmux-sessionoptionvalues-assumepastetime"},{"id":"tmux.SessionOptionValues.BaseIndex","name":"BaseIndex","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"BaseIndex returns materialized \"base-index\" as [OptionValue] with value type OptionValue[int64] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetBaseIndex] or [GlobalSessionScope.SetBaseIndex]."},"source":{"file":"tmux/option_generated.go","line":2088,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.BaseIndex","product":"core","slug":"tmux-sessionoptionvalues-baseindex"},{"id":"tmux.SessionOptionValues.BellAction","name":"BellAction","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[BellAction]"}],"doc":{"summary":"BellAction returns materialized \"bell-action\" as [OptionValue] with value type OptionValue[BellAction] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"none\", \"any\", \"current\", \"other\"); set it with [Session.SetBellAction] or [GlobalSessionScope.SetBellAction]."},"source":{"file":"tmux/option_generated.go","line":2092,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.BellAction","product":"core","slug":"tmux-sessionoptionvalues-bellaction"},{"id":"tmux.SessionOptionValues.DefaultCommand","name":"DefaultCommand","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultCommand returns materialized \"default-command\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetDefaultCommand] or [GlobalSessionScope.SetDefaultCommand]."},"source":{"file":"tmux/option_generated.go","line":2096,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DefaultCommand","product":"core","slug":"tmux-sessionoptionvalues-defaultcommand"},{"id":"tmux.SessionOptionValues.DefaultShell","name":"DefaultShell","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultShell returns materialized \"default-shell\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetDefaultShell] or [GlobalSessionScope.SetDefaultShell]."},"source":{"file":"tmux/option_generated.go","line":2100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DefaultShell","product":"core","slug":"tmux-sessionoptionvalues-defaultshell"},{"id":"tmux.SessionOptionValues.DefaultSize","name":"DefaultSize","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DefaultSize returns materialized \"default-size\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetDefaultSize] or [GlobalSessionScope.SetDefaultSize]."},"source":{"file":"tmux/option_generated.go","line":2104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DefaultSize","product":"core","slug":"tmux-sessionoptionvalues-defaultsize"},{"id":"tmux.SessionOptionValues.DestroyUnattached","name":"DestroyUnattached","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[DestroyUnattached]"}],"doc":{"summary":"DestroyUnattached returns materialized \"destroy-unattached\" as [OptionValue] with value type OptionValue[DestroyUnattached] from session option values; it does not query tmux. Available as FLAG since tmux 3.2a; CHOICE since tmux 3.4 (choices: \"off\", \"on\", \"keep-last\", \"keep-group\"); set it with [Session.SetDestroyUnattached] or [GlobalSessionScope.SetDestroyUnattached]."},"source":{"file":"tmux/option_generated.go","line":2108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DestroyUnattached","product":"core","slug":"tmux-sessionoptionvalues-destroyunattached"},{"id":"tmux.SessionOptionValues.DetachOnDestroy","name":"DetachOnDestroy","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[DetachOnDestroy]"}],"doc":{"summary":"DetachOnDestroy returns materialized \"detach-on-destroy\" as [OptionValue] with value type OptionValue[DetachOnDestroy] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"no-detached\"); CHOICE since tmux 3.4 (choices: \"off\", \"on\", \"no-detached\", \"previous\", \"next\"); set it with [Session.SetDetachOnDestroy] or [GlobalSessionScope.SetDetachOnDestroy]."},"source":{"file":"tmux/option_generated.go","line":2114,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DetachOnDestroy","product":"core","slug":"tmux-sessionoptionvalues-detachondestroy"},{"id":"tmux.SessionOptionValues.DisplayPanesActiveColour","name":"DisplayPanesActiveColour","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DisplayPanesActiveColour returns materialized \"display-panes-active-colour\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Session.SetDisplayPanesActiveColour] or [GlobalSessionScope.SetDisplayPanesActiveColour]."},"source":{"file":"tmux/option_generated.go","line":2118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DisplayPanesActiveColour","product":"core","slug":"tmux-sessionoptionvalues-displaypanesactivecolour"},{"id":"tmux.SessionOptionValues.DisplayPanesColour","name":"DisplayPanesColour","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"DisplayPanesColour returns materialized \"display-panes-colour\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Session.SetDisplayPanesColour] or [GlobalSessionScope.SetDisplayPanesColour]."},"source":{"file":"tmux/option_generated.go","line":2124,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DisplayPanesColour","product":"core","slug":"tmux-sessionoptionvalues-displaypanescolour"},{"id":"tmux.SessionOptionValues.DisplayPanesTime","name":"DisplayPanesTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"DisplayPanesTime returns materialized \"display-panes-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetDisplayPanesTime] or [GlobalSessionScope.SetDisplayPanesTime]."},"source":{"file":"tmux/option_generated.go","line":2128,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DisplayPanesTime","product":"core","slug":"tmux-sessionoptionvalues-displaypanestime"},{"id":"tmux.SessionOptionValues.DisplayTime","name":"DisplayTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"DisplayTime returns materialized \"display-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetDisplayTime] or [GlobalSessionScope.SetDisplayTime]."},"source":{"file":"tmux/option_generated.go","line":2132,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.DisplayTime","product":"core","slug":"tmux-sessionoptionvalues-displaytime"},{"id":"tmux.SessionOptionValues.FocusFollowsMouse","name":"FocusFollowsMouse","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"FocusFollowsMouse returns materialized \"focus-follows-mouse\" as [OptionValue] with value type OptionValue[bool] from session option values; it does not query tmux. Available as FLAG since tmux 3.7; set it with [Session.SetFocusFollowsMouse] or [GlobalSessionScope.SetFocusFollowsMouse]."},"source":{"file":"tmux/option_generated.go","line":2136,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.FocusFollowsMouse","product":"core","slug":"tmux-sessionoptionvalues-focusfollowsmouse"},{"id":"tmux.SessionOptionValues.HistoryLimit","name":"HistoryLimit","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"HistoryLimit returns materialized \"history-limit\" as [OptionValue] with value type OptionValue[int64] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetHistoryLimit] or [GlobalSessionScope.SetHistoryLimit]."},"source":{"file":"tmux/option_generated.go","line":2140,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.HistoryLimit","product":"core","slug":"tmux-sessionoptionvalues-historylimit"},{"id":"tmux.SessionOptionValues.InitialRepeatTime","name":"InitialRepeatTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"InitialRepeatTime returns materialized \"initial-repeat-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.6; set it with [Session.SetInitialRepeatTime] or [GlobalSessionScope.SetInitialRepeatTime]."},"source":{"file":"tmux/option_generated.go","line":2144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.InitialRepeatTime","product":"core","slug":"tmux-sessionoptionvalues-initialrepeattime"},{"id":"tmux.SessionOptionValues.KeyTable","name":"KeyTable","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"KeyTable returns materialized \"key-table\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetKeyTable] or [GlobalSessionScope.SetKeyTable]."},"source":{"file":"tmux/option_generated.go","line":2150,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.KeyTable","product":"core","slug":"tmux-sessionoptionvalues-keytable"},{"id":"tmux.SessionOptionValues.LockAfterTime","name":"LockAfterTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"LockAfterTime returns materialized \"lock-after-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetLockAfterTime] or [GlobalSessionScope.SetLockAfterTime]."},"source":{"file":"tmux/option_generated.go","line":2154,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.LockAfterTime","product":"core","slug":"tmux-sessionoptionvalues-lockaftertime"},{"id":"tmux.SessionOptionValues.LockCommand","name":"LockCommand","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"LockCommand returns materialized \"lock-command\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetLockCommand] or [GlobalSessionScope.SetLockCommand]."},"source":{"file":"tmux/option_generated.go","line":2158,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.LockCommand","product":"core","slug":"tmux-sessionoptionvalues-lockcommand"},{"id":"tmux.SessionOptionValues.MessageCommandStyle","name":"MessageCommandStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MessageCommandStyle returns materialized \"message-command-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetMessageCommandStyle] or [GlobalSessionScope.SetMessageCommandStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2163,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.MessageCommandStyle","product":"core","slug":"tmux-sessionoptionvalues-messagecommandstyle"},{"id":"tmux.SessionOptionValues.MessageFormat","name":"MessageFormat","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MessageFormat returns materialized \"message-format\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Session.SetMessageFormat] or [GlobalSessionScope.SetMessageFormat]."},"source":{"file":"tmux/option_generated.go","line":2167,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.MessageFormat","product":"core","slug":"tmux-sessionoptionvalues-messageformat"},{"id":"tmux.SessionOptionValues.MessageLine","name":"MessageLine","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[MessageLine]"}],"doc":{"summary":"MessageLine returns materialized \"message-line\" as [OptionValue] with value type OptionValue[MessageLine] from session option values; it does not query tmux. Available as CHOICE since tmux 3.4 (choices: \"0\", \"1\", \"2\", \"3\", \"4\"); set it with [Session.SetMessageLine] or [GlobalSessionScope.SetMessageLine]."},"source":{"file":"tmux/option_generated.go","line":2171,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.MessageLine","product":"core","slug":"tmux-sessionoptionvalues-messageline"},{"id":"tmux.SessionOptionValues.MessageStyle","name":"MessageStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MessageStyle returns materialized \"message-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetMessageStyle] or [GlobalSessionScope.SetMessageStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2176,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.MessageStyle","product":"core","slug":"tmux-sessionoptionvalues-messagestyle"},{"id":"tmux.SessionOptionValues.Mouse","name":"Mouse","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"Mouse returns materialized \"mouse\" as [OptionValue] with value type OptionValue[bool] from session option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Session.SetMouse] or [GlobalSessionScope.SetMouse]."},"source":{"file":"tmux/option_generated.go","line":2180,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.Mouse","product":"core","slug":"tmux-sessionoptionvalues-mouse"},{"id":"tmux.SessionOptionValues.Prefix","name":"Prefix","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"Prefix returns materialized \"prefix\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as KEY since tmux 3.2a; set it with [Session.SetPrefix] or [GlobalSessionScope.SetPrefix]."},"source":{"file":"tmux/option_generated.go","line":2184,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.Prefix","product":"core","slug":"tmux-sessionoptionvalues-prefix"},{"id":"tmux.SessionOptionValues.Prefix2","name":"Prefix2","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"Prefix2 returns materialized \"prefix2\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as KEY since tmux 3.2a; set it with [Session.SetPrefix2] or [GlobalSessionScope.SetPrefix2]."},"source":{"file":"tmux/option_generated.go","line":2188,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.Prefix2","product":"core","slug":"tmux-sessionoptionvalues-prefix2"},{"id":"tmux.SessionOptionValues.PromptCommandCursorStyle","name":"PromptCommandCursorStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[PromptCommandCursorStyle]"}],"doc":{"summary":"PromptCommandCursorStyle returns materialized \"prompt-command-cursor-style\" as [OptionValue] with value type OptionValue[PromptCommandCursorStyle] from session option values; it does not query tmux. Available as CHOICE since tmux 3.7 (choices: \"default\", \"blinking-block\", \"block\", \"blinking-underline\", \"underline\", \"blinking-bar\", \"bar\"); set it with [Session.SetPromptCommandCursorStyle] or [GlobalSessionScope.SetPromptCommandCursorStyle]."},"source":{"file":"tmux/option_generated.go","line":2192,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.PromptCommandCursorStyle","product":"core","slug":"tmux-sessionoptionvalues-promptcommandcursorstyle"},{"id":"tmux.SessionOptionValues.PromptCursorColour","name":"PromptCursorColour","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PromptCursorColour returns materialized \"prompt-cursor-colour\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.6; set it with [Session.SetPromptCursorColour] or [GlobalSessionScope.SetPromptCursorColour]."},"source":{"file":"tmux/option_generated.go","line":2198,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.PromptCursorColour","product":"core","slug":"tmux-sessionoptionvalues-promptcursorcolour"},{"id":"tmux.SessionOptionValues.PromptCursorStyle","name":"PromptCursorStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[PromptCursorStyle]"}],"doc":{"summary":"PromptCursorStyle returns materialized \"prompt-cursor-style\" as [OptionValue] with value type OptionValue[PromptCursorStyle] from session option values; it does not query tmux. Available as CHOICE since tmux 3.6 (choices: \"default\", \"blinking-block\", \"block\", \"blinking-underline\", \"underline\", \"blinking-bar\", \"bar\"); set it with [Session.SetPromptCursorStyle] or [GlobalSessionScope.SetPromptCursorStyle]."},"source":{"file":"tmux/option_generated.go","line":2202,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.PromptCursorStyle","product":"core","slug":"tmux-sessionoptionvalues-promptcursorstyle"},{"id":"tmux.SessionOptionValues.RenumberWindows","name":"RenumberWindows","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"RenumberWindows returns materialized \"renumber-windows\" as [OptionValue] with value type OptionValue[bool] from session option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Session.SetRenumberWindows] or [GlobalSessionScope.SetRenumberWindows]."},"source":{"file":"tmux/option_generated.go","line":2208,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.RenumberWindows","product":"core","slug":"tmux-sessionoptionvalues-renumberwindows"},{"id":"tmux.SessionOptionValues.RepeatTime","name":"RepeatTime","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"RepeatTime returns materialized \"repeat-time\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetRepeatTime] or [GlobalSessionScope.SetRepeatTime]."},"source":{"file":"tmux/option_generated.go","line":2212,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.RepeatTime","product":"core","slug":"tmux-sessionoptionvalues-repeattime"},{"id":"tmux.SessionOptionValues.SetTitles","name":"SetTitles","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"SetTitles returns materialized \"set-titles\" as [OptionValue] with value type OptionValue[bool] from session option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Session.SetTitles] or [GlobalSessionScope.SetTitles]."},"source":{"file":"tmux/option_generated.go","line":2216,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.SetTitles","product":"core","slug":"tmux-sessionoptionvalues-settitles"},{"id":"tmux.SessionOptionValues.SetTitlesString","name":"SetTitlesString","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"SetTitlesString returns materialized \"set-titles-string\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetTitlesString] or [GlobalSessionScope.SetTitlesString]."},"source":{"file":"tmux/option_generated.go","line":2220,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.SetTitlesString","product":"core","slug":"tmux-sessionoptionvalues-settitlesstring"},{"id":"tmux.SessionOptionValues.SilenceAction","name":"SilenceAction","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[SilenceAction]"}],"doc":{"summary":"SilenceAction returns materialized \"silence-action\" as [OptionValue] with value type OptionValue[SilenceAction] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"none\", \"any\", \"current\", \"other\"); set it with [Session.SetSilenceAction] or [GlobalSessionScope.SetSilenceAction]."},"source":{"file":"tmux/option_generated.go","line":2224,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.SilenceAction","product":"core","slug":"tmux-sessionoptionvalues-silenceaction"},{"id":"tmux.SessionOptionValues.Status","name":"Status","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[Status]"}],"doc":{"summary":"Status returns materialized \"status\" as [OptionValue] with value type OptionValue[Status] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"2\", \"3\", \"4\", \"5\"); set it with [Session.SetStatus] or [GlobalSessionScope.SetStatus]."},"source":{"file":"tmux/option_generated.go","line":2228,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.Status","product":"core","slug":"tmux-sessionoptionvalues-status"},{"id":"tmux.SessionOptionValues.StatusBG","name":"StatusBG","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusBG returns materialized \"status-bg\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Session.SetStatusBG] or [GlobalSessionScope.SetStatusBG]."},"source":{"file":"tmux/option_generated.go","line":2232,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusBG","product":"core","slug":"tmux-sessionoptionvalues-statusbg"},{"id":"tmux.SessionOptionValues.StatusFG","name":"StatusFG","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusFG returns materialized \"status-fg\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Session.SetStatusFG] or [GlobalSessionScope.SetStatusFG]."},"source":{"file":"tmux/option_generated.go","line":2236,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusFG","product":"core","slug":"tmux-sessionoptionvalues-statusfg"},{"id":"tmux.SessionOptionValues.StatusFormat","name":"StatusFormat","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"StatusFormat returns materialized \"status-format\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusFormat] or [GlobalSessionScope.SetStatusFormat]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":2241,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusFormat","product":"core","slug":"tmux-sessionoptionvalues-statusformat"},{"id":"tmux.SessionOptionValues.StatusInterval","name":"StatusInterval","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[time.Duration]"}],"doc":{"summary":"StatusInterval returns materialized \"status-interval\" as [OptionValue] with value type OptionValue[time.Duration] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetStatusInterval] or [GlobalSessionScope.SetStatusInterval]."},"source":{"file":"tmux/option_generated.go","line":2245,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusInterval","product":"core","slug":"tmux-sessionoptionvalues-statusinterval"},{"id":"tmux.SessionOptionValues.StatusJustify","name":"StatusJustify","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[StatusJustify]"}],"doc":{"summary":"StatusJustify returns materialized \"status-justify\" as [OptionValue] with value type OptionValue[StatusJustify] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"left\", \"centre\", \"right\", \"absolute-centre\"); set it with [Session.SetStatusJustify] or [GlobalSessionScope.SetStatusJustify]."},"source":{"file":"tmux/option_generated.go","line":2249,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusJustify","product":"core","slug":"tmux-sessionoptionvalues-statusjustify"},{"id":"tmux.SessionOptionValues.StatusKeys","name":"StatusKeys","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[StatusKeys]"}],"doc":{"summary":"StatusKeys returns materialized \"status-keys\" as [OptionValue] with value type OptionValue[StatusKeys] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"emacs\", \"vi\"); set it with [Session.SetStatusKeys] or [GlobalSessionScope.SetStatusKeys]."},"source":{"file":"tmux/option_generated.go","line":2253,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusKeys","product":"core","slug":"tmux-sessionoptionvalues-statuskeys"},{"id":"tmux.SessionOptionValues.StatusLeft","name":"StatusLeft","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusLeft returns materialized \"status-left\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusLeft] or [GlobalSessionScope.SetStatusLeft]."},"source":{"file":"tmux/option_generated.go","line":2257,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusLeft","product":"core","slug":"tmux-sessionoptionvalues-statusleft"},{"id":"tmux.SessionOptionValues.StatusLeftLength","name":"StatusLeftLength","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"StatusLeftLength returns materialized \"status-left-length\" as [OptionValue] with value type OptionValue[int64] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetStatusLeftLength] or [GlobalSessionScope.SetStatusLeftLength]."},"source":{"file":"tmux/option_generated.go","line":2261,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusLeftLength","product":"core","slug":"tmux-sessionoptionvalues-statusleftlength"},{"id":"tmux.SessionOptionValues.StatusLeftStyle","name":"StatusLeftStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusLeftStyle returns materialized \"status-left-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusLeftStyle] or [GlobalSessionScope.SetStatusLeftStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2266,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusLeftStyle","product":"core","slug":"tmux-sessionoptionvalues-statusleftstyle"},{"id":"tmux.SessionOptionValues.StatusPosition","name":"StatusPosition","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[StatusPosition]"}],"doc":{"summary":"StatusPosition returns materialized \"status-position\" as [OptionValue] with value type OptionValue[StatusPosition] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"top\", \"bottom\"); set it with [Session.SetStatusPosition] or [GlobalSessionScope.SetStatusPosition]."},"source":{"file":"tmux/option_generated.go","line":2270,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusPosition","product":"core","slug":"tmux-sessionoptionvalues-statusposition"},{"id":"tmux.SessionOptionValues.StatusRight","name":"StatusRight","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusRight returns materialized \"status-right\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusRight] or [GlobalSessionScope.SetStatusRight]."},"source":{"file":"tmux/option_generated.go","line":2274,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusRight","product":"core","slug":"tmux-sessionoptionvalues-statusright"},{"id":"tmux.SessionOptionValues.StatusRightLength","name":"StatusRightLength","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"StatusRightLength returns materialized \"status-right-length\" as [OptionValue] with value type OptionValue[int64] from session option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Session.SetStatusRightLength] or [GlobalSessionScope.SetStatusRightLength]."},"source":{"file":"tmux/option_generated.go","line":2278,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusRightLength","product":"core","slug":"tmux-sessionoptionvalues-statusrightlength"},{"id":"tmux.SessionOptionValues.StatusRightStyle","name":"StatusRightStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusRightStyle returns materialized \"status-right-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusRightStyle] or [GlobalSessionScope.SetStatusRightStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2283,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusRightStyle","product":"core","slug":"tmux-sessionoptionvalues-statusrightstyle"},{"id":"tmux.SessionOptionValues.StatusStyle","name":"StatusStyle","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"StatusStyle returns materialized \"status-style\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetStatusStyle] or [GlobalSessionScope.SetStatusStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2288,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.StatusStyle","product":"core","slug":"tmux-sessionoptionvalues-statusstyle"},{"id":"tmux.SessionOptionValues.UpdateEnvironment","name":"UpdateEnvironment","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"UpdateEnvironment returns materialized \"update-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetUpdateEnvironment] or [GlobalSessionScope.SetUpdateEnvironment]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":2293,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.UpdateEnvironment","product":"core","slug":"tmux-sessionoptionvalues-updateenvironment"},{"id":"tmux.SessionOptionValues.VisualActivity","name":"VisualActivity","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[VisualActivity]"}],"doc":{"summary":"VisualActivity returns materialized \"visual-activity\" as [OptionValue] with value type OptionValue[VisualActivity] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"both\"); set it with [Session.SetVisualActivity] or [GlobalSessionScope.SetVisualActivity]."},"source":{"file":"tmux/option_generated.go","line":2299,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.VisualActivity","product":"core","slug":"tmux-sessionoptionvalues-visualactivity"},{"id":"tmux.SessionOptionValues.VisualBell","name":"VisualBell","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[VisualBell]"}],"doc":{"summary":"VisualBell returns materialized \"visual-bell\" as [OptionValue] with value type OptionValue[VisualBell] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"both\"); set it with [Session.SetVisualBell] or [GlobalSessionScope.SetVisualBell]."},"source":{"file":"tmux/option_generated.go","line":2303,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.VisualBell","product":"core","slug":"tmux-sessionoptionvalues-visualbell"},{"id":"tmux.SessionOptionValues.VisualSilence","name":"VisualSilence","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[VisualSilence]"}],"doc":{"summary":"VisualSilence returns materialized \"visual-silence\" as [OptionValue] with value type OptionValue[VisualSilence] from session option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"both\"); set it with [Session.SetVisualSilence] or [GlobalSessionScope.SetVisualSilence]."},"source":{"file":"tmux/option_generated.go","line":2307,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.VisualSilence","product":"core","slug":"tmux-sessionoptionvalues-visualsilence"},{"id":"tmux.SessionOptionValues.WordSeparators","name":"WordSeparators","kind":"method","modifiers":[],"parent":"tmux.SessionOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WordSeparators returns materialized \"word-separators\" as [OptionValue] with value type OptionValue[string] from session option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Session.SetWordSeparators] or [GlobalSessionScope.SetWordSeparators]."},"source":{"file":"tmux/option_generated.go","line":2311,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionOptionValues.WordSeparators","product":"core","slug":"tmux-sessionoptionvalues-wordseparators"},{"id":"tmux.WindowOptionValues","name":"WindowOptionValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowOptionValues is an immutable materialized view of known window option values; its zero value is empty and it does not refresh. Obtain it with [Window.Options] or [GlobalWindowScope.Options]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Window.RawOption] or [GlobalWindowScope.RawOption] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":2433,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues","product":"core","slug":"tmux-windowoptionvalues"},{"id":"tmux.WindowOptionValues.AggressiveResize","name":"AggressiveResize","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AggressiveResize returns materialized \"aggressive-resize\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetAggressiveResize] or [GlobalWindowScope.SetAggressiveResize]."},"source":{"file":"tmux/option_generated.go","line":2512,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.AggressiveResize","product":"core","slug":"tmux-windowoptionvalues-aggressiveresize"},{"id":"tmux.WindowOptionValues.AllowPassthrough","name":"AllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[AllowPassthrough]"}],"doc":{"summary":"AllowPassthrough returns materialized \"allow-passthrough\" as [OptionValue] with value type OptionValue[AllowPassthrough] from window option values; it does not query tmux. Available as FLAG since tmux 3.3; CHOICE since tmux 3.4 (choices: \"off\", \"on\", \"all\"); set it with [Window.SetAllowPassthrough] or [GlobalWindowScope.SetAllowPassthrough]."},"source":{"file":"tmux/option_generated.go","line":2516,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.AllowPassthrough","product":"core","slug":"tmux-windowoptionvalues-allowpassthrough"},{"id":"tmux.WindowOptionValues.AllowRename","name":"AllowRename","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AllowRename returns materialized \"allow-rename\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetAllowRename] or [GlobalWindowScope.SetAllowRename]."},"source":{"file":"tmux/option_generated.go","line":2522,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.AllowRename","product":"core","slug":"tmux-windowoptionvalues-allowrename"},{"id":"tmux.WindowOptionValues.AllowSetTitle","name":"AllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AllowSetTitle returns materialized \"allow-set-title\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.5; set it with [Window.SetAllowSetTitle] or [GlobalWindowScope.SetAllowSetTitle]."},"source":{"file":"tmux/option_generated.go","line":2526,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.AllowSetTitle","product":"core","slug":"tmux-windowoptionvalues-allowsettitle"},{"id":"tmux.WindowOptionValues.AlternateScreen","name":"AlternateScreen","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AlternateScreen returns materialized \"alternate-screen\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetAlternateScreen] or [GlobalWindowScope.SetAlternateScreen]."},"source":{"file":"tmux/option_generated.go","line":2530,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.AlternateScreen","product":"core","slug":"tmux-windowoptionvalues-alternatescreen"},{"id":"tmux.WindowOptionValues.AutomaticRename","name":"AutomaticRename","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AutomaticRename returns materialized \"automatic-rename\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetAutomaticRename] or [GlobalWindowScope.SetAutomaticRename]."},"source":{"file":"tmux/option_generated.go","line":2534,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.AutomaticRename","product":"core","slug":"tmux-windowoptionvalues-automaticrename"},{"id":"tmux.WindowOptionValues.AutomaticRenameFormat","name":"AutomaticRenameFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"AutomaticRenameFormat returns materialized \"automatic-rename-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetAutomaticRenameFormat] or [GlobalWindowScope.SetAutomaticRenameFormat]."},"source":{"file":"tmux/option_generated.go","line":2538,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.AutomaticRenameFormat","product":"core","slug":"tmux-windowoptionvalues-automaticrenameformat"},{"id":"tmux.WindowOptionValues.ClockModeColour","name":"ClockModeColour","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"ClockModeColour returns materialized \"clock-mode-colour\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as COLOUR since tmux 3.2a; set it with [Window.SetClockModeColour] or [GlobalWindowScope.SetClockModeColour]."},"source":{"file":"tmux/option_generated.go","line":2544,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.ClockModeColour","product":"core","slug":"tmux-windowoptionvalues-clockmodecolour"},{"id":"tmux.WindowOptionValues.ClockModeStyle","name":"ClockModeStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[ClockModeStyle]"}],"doc":{"summary":"ClockModeStyle returns materialized \"clock-mode-style\" as [OptionValue] with value type OptionValue[ClockModeStyle] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"12\", \"24\"); CHOICE since tmux 3.6 (choices: \"12\", \"24\", \"12-with-seconds\", \"24-with-seconds\"); set it with [Window.SetClockModeStyle] or [GlobalWindowScope.SetClockModeStyle]."},"source":{"file":"tmux/option_generated.go","line":2548,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.ClockModeStyle","product":"core","slug":"tmux-windowoptionvalues-clockmodestyle"},{"id":"tmux.WindowOptionValues.CopyModeCurrentLineNumberStyle","name":"CopyModeCurrentLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeCurrentLineNumberStyle returns materialized \"copy-mode-current-line-number-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetCopyModeCurrentLineNumberStyle] or [GlobalWindowScope.SetCopyModeCurrentLineNumberStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2553,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModeCurrentLineNumberStyle","product":"core","slug":"tmux-windowoptionvalues-copymodecurrentlinenumberstyle"},{"id":"tmux.WindowOptionValues.CopyModeCurrentMatchStyle","name":"CopyModeCurrentMatchStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeCurrentMatchStyle returns materialized \"copy-mode-current-match-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetCopyModeCurrentMatchStyle] or [GlobalWindowScope.SetCopyModeCurrentMatchStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2560,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModeCurrentMatchStyle","product":"core","slug":"tmux-windowoptionvalues-copymodecurrentmatchstyle"},{"id":"tmux.WindowOptionValues.CopyModeLineNumberStyle","name":"CopyModeLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeLineNumberStyle returns materialized \"copy-mode-line-number-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetCopyModeLineNumberStyle] or [GlobalWindowScope.SetCopyModeLineNumberStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2567,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModeLineNumberStyle","product":"core","slug":"tmux-windowoptionvalues-copymodelinenumberstyle"},{"id":"tmux.WindowOptionValues.CopyModeLineNumbers","name":"CopyModeLineNumbers","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[CopyModeLineNumbers]"}],"doc":{"summary":"CopyModeLineNumbers returns materialized \"copy-mode-line-numbers\" as [OptionValue] with value type OptionValue[CopyModeLineNumbers] from window option values; it does not query tmux. Available as CHOICE since tmux 3.7 (choices: \"off\", \"default\", \"absolute\", \"relative\", \"hybrid\"); set it with [Window.SetCopyModeLineNumbers] or [GlobalWindowScope.SetCopyModeLineNumbers]."},"source":{"file":"tmux/option_generated.go","line":2573,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModeLineNumbers","product":"core","slug":"tmux-windowoptionvalues-copymodelinenumbers"},{"id":"tmux.WindowOptionValues.CopyModeMarkStyle","name":"CopyModeMarkStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeMarkStyle returns materialized \"copy-mode-mark-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetCopyModeMarkStyle] or [GlobalWindowScope.SetCopyModeMarkStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2580,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModeMarkStyle","product":"core","slug":"tmux-windowoptionvalues-copymodemarkstyle"},{"id":"tmux.WindowOptionValues.CopyModeMatchStyle","name":"CopyModeMatchStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeMatchStyle returns materialized \"copy-mode-match-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetCopyModeMatchStyle] or [GlobalWindowScope.SetCopyModeMatchStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2585,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModeMatchStyle","product":"core","slug":"tmux-windowoptionvalues-copymodematchstyle"},{"id":"tmux.WindowOptionValues.CopyModePositionFormat","name":"CopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModePositionFormat returns materialized \"copy-mode-position-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetCopyModePositionFormat] or [GlobalWindowScope.SetCopyModePositionFormat]."},"source":{"file":"tmux/option_generated.go","line":2589,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModePositionFormat","product":"core","slug":"tmux-windowoptionvalues-copymodepositionformat"},{"id":"tmux.WindowOptionValues.CopyModePositionStyle","name":"CopyModePositionStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModePositionStyle returns materialized \"copy-mode-position-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetCopyModePositionStyle] or [GlobalWindowScope.SetCopyModePositionStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2596,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModePositionStyle","product":"core","slug":"tmux-windowoptionvalues-copymodepositionstyle"},{"id":"tmux.WindowOptionValues.CopyModeSelectionStyle","name":"CopyModeSelectionStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModeSelectionStyle returns materialized \"copy-mode-selection-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetCopyModeSelectionStyle] or [GlobalWindowScope.SetCopyModeSelectionStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2603,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CopyModeSelectionStyle","product":"core","slug":"tmux-windowoptionvalues-copymodeselectionstyle"},{"id":"tmux.WindowOptionValues.CursorColour","name":"CursorColour","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CursorColour returns materialized \"cursor-colour\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as COLOUR since tmux 3.3; set it with [Window.SetCursorColour] or [GlobalWindowScope.SetCursorColour]."},"source":{"file":"tmux/option_generated.go","line":2609,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CursorColour","product":"core","slug":"tmux-windowoptionvalues-cursorcolour"},{"id":"tmux.WindowOptionValues.CursorStyle","name":"CursorStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[CursorStyle]"}],"doc":{"summary":"CursorStyle returns materialized \"cursor-style\" as [OptionValue] with value type OptionValue[CursorStyle] from window option values; it does not query tmux. Available as CHOICE since tmux 3.3 (choices: \"default\", \"blinking-block\", \"block\", \"blinking-underline\", \"underline\", \"blinking-bar\", \"bar\"); set it with [Window.SetCursorStyle] or [GlobalWindowScope.SetCursorStyle]."},"source":{"file":"tmux/option_generated.go","line":2613,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.CursorStyle","product":"core","slug":"tmux-windowoptionvalues-cursorstyle"},{"id":"tmux.WindowOptionValues.FillCharacter","name":"FillCharacter","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"FillCharacter returns materialized \"fill-character\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Window.SetFillCharacter] or [GlobalWindowScope.SetFillCharacter]."},"source":{"file":"tmux/option_generated.go","line":2617,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.FillCharacter","product":"core","slug":"tmux-windowoptionvalues-fillcharacter"},{"id":"tmux.WindowOptionValues.MainPaneHeight","name":"MainPaneHeight","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MainPaneHeight returns materialized \"main-pane-height\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetMainPaneHeight] or [GlobalWindowScope.SetMainPaneHeight]."},"source":{"file":"tmux/option_generated.go","line":2621,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MainPaneHeight","product":"core","slug":"tmux-windowoptionvalues-mainpaneheight"},{"id":"tmux.WindowOptionValues.MainPaneWidth","name":"MainPaneWidth","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MainPaneWidth returns materialized \"main-pane-width\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetMainPaneWidth] or [GlobalWindowScope.SetMainPaneWidth]."},"source":{"file":"tmux/option_generated.go","line":2625,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MainPaneWidth","product":"core","slug":"tmux-windowoptionvalues-mainpanewidth"},{"id":"tmux.WindowOptionValues.MenuBorderLines","name":"MenuBorderLines","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[MenuBorderLines]"}],"doc":{"summary":"MenuBorderLines returns materialized \"menu-border-lines\" as [OptionValue] with value type OptionValue[MenuBorderLines] from window option values; it does not query tmux. Available as CHOICE since tmux 3.4 (choices: \"single\", \"double\", \"heavy\", \"simple\", \"rounded\", \"padded\", \"none\"); set it with [Window.SetMenuBorderLines] or [GlobalWindowScope.SetMenuBorderLines]."},"source":{"file":"tmux/option_generated.go","line":2629,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MenuBorderLines","product":"core","slug":"tmux-windowoptionvalues-menuborderlines"},{"id":"tmux.WindowOptionValues.MenuBorderStyle","name":"MenuBorderStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MenuBorderStyle returns materialized \"menu-border-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.4; set it with [Window.SetMenuBorderStyle] or [GlobalWindowScope.SetMenuBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2634,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MenuBorderStyle","product":"core","slug":"tmux-windowoptionvalues-menuborderstyle"},{"id":"tmux.WindowOptionValues.MenuSelectedStyle","name":"MenuSelectedStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MenuSelectedStyle returns materialized \"menu-selected-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.4; set it with [Window.SetMenuSelectedStyle] or [GlobalWindowScope.SetMenuSelectedStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2639,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MenuSelectedStyle","product":"core","slug":"tmux-windowoptionvalues-menuselectedstyle"},{"id":"tmux.WindowOptionValues.MenuStyle","name":"MenuStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"MenuStyle returns materialized \"menu-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.4; set it with [Window.SetMenuStyle] or [GlobalWindowScope.SetMenuStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2644,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MenuStyle","product":"core","slug":"tmux-windowoptionvalues-menustyle"},{"id":"tmux.WindowOptionValues.ModeKeys","name":"ModeKeys","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[ModeKeys]"}],"doc":{"summary":"ModeKeys returns materialized \"mode-keys\" as [OptionValue] with value type OptionValue[ModeKeys] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"emacs\", \"vi\"); set it with [Window.SetModeKeys] or [GlobalWindowScope.SetModeKeys]."},"source":{"file":"tmux/option_generated.go","line":2648,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.ModeKeys","product":"core","slug":"tmux-windowoptionvalues-modekeys"},{"id":"tmux.WindowOptionValues.ModeStyle","name":"ModeStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"ModeStyle returns materialized \"mode-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetModeStyle] or [GlobalWindowScope.SetModeStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2653,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.ModeStyle","product":"core","slug":"tmux-windowoptionvalues-modestyle"},{"id":"tmux.WindowOptionValues.MonitorActivity","name":"MonitorActivity","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"MonitorActivity returns materialized \"monitor-activity\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetMonitorActivity] or [GlobalWindowScope.SetMonitorActivity]."},"source":{"file":"tmux/option_generated.go","line":2657,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MonitorActivity","product":"core","slug":"tmux-windowoptionvalues-monitoractivity"},{"id":"tmux.WindowOptionValues.MonitorBell","name":"MonitorBell","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"MonitorBell returns materialized \"monitor-bell\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetMonitorBell] or [GlobalWindowScope.SetMonitorBell]."},"source":{"file":"tmux/option_generated.go","line":2661,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MonitorBell","product":"core","slug":"tmux-windowoptionvalues-monitorbell"},{"id":"tmux.WindowOptionValues.MonitorSilence","name":"MonitorSilence","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"MonitorSilence returns materialized \"monitor-silence\" as [OptionValue] with value type OptionValue[int64] from window option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Window.SetMonitorSilence] or [GlobalWindowScope.SetMonitorSilence]."},"source":{"file":"tmux/option_generated.go","line":2665,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.MonitorSilence","product":"core","slug":"tmux-windowoptionvalues-monitorsilence"},{"id":"tmux.WindowOptionValues.OtherPaneHeight","name":"OtherPaneHeight","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"OtherPaneHeight returns materialized \"other-pane-height\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetOtherPaneHeight] or [GlobalWindowScope.SetOtherPaneHeight]."},"source":{"file":"tmux/option_generated.go","line":2669,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.OtherPaneHeight","product":"core","slug":"tmux-windowoptionvalues-otherpaneheight"},{"id":"tmux.WindowOptionValues.OtherPaneWidth","name":"OtherPaneWidth","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"OtherPaneWidth returns materialized \"other-pane-width\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetOtherPaneWidth] or [GlobalWindowScope.SetOtherPaneWidth]."},"source":{"file":"tmux/option_generated.go","line":2673,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.OtherPaneWidth","product":"core","slug":"tmux-windowoptionvalues-otherpanewidth"},{"id":"tmux.WindowOptionValues.PaneActiveBorderStyle","name":"PaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneActiveBorderStyle returns materialized \"pane-active-border-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; STRING since tmux 3.7; set it with [Window.SetPaneActiveBorderStyle] or [GlobalWindowScope.SetPaneActiveBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2678,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneActiveBorderStyle","product":"core","slug":"tmux-windowoptionvalues-paneactiveborderstyle"},{"id":"tmux.WindowOptionValues.PaneBaseIndex","name":"PaneBaseIndex","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"PaneBaseIndex returns materialized \"pane-base-index\" as [OptionValue] with value type OptionValue[int64] from window option values; it does not query tmux. Available as NUMBER since tmux 3.2a; set it with [Window.SetPaneBaseIndex] or [GlobalWindowScope.SetPaneBaseIndex]."},"source":{"file":"tmux/option_generated.go","line":2684,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneBaseIndex","product":"core","slug":"tmux-windowoptionvalues-panebaseindex"},{"id":"tmux.WindowOptionValues.PaneBorderFormat","name":"PaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneBorderFormat returns materialized \"pane-border-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; STRING since tmux 3.3; set it with [Window.SetPaneBorderFormat] or [GlobalWindowScope.SetPaneBorderFormat]."},"source":{"file":"tmux/option_generated.go","line":2688,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneBorderFormat","product":"core","slug":"tmux-windowoptionvalues-paneborderformat"},{"id":"tmux.WindowOptionValues.PaneBorderIndicators","name":"PaneBorderIndicators","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneBorderIndicators]"}],"doc":{"summary":"PaneBorderIndicators returns materialized \"pane-border-indicators\" as [OptionValue] with value type OptionValue[PaneBorderIndicators] from window option values; it does not query tmux. Available as CHOICE since tmux 3.3 (choices: \"off\", \"colour\", \"arrows\", \"both\"); set it with [Window.SetPaneBorderIndicators] or [GlobalWindowScope.SetPaneBorderIndicators]."},"source":{"file":"tmux/option_generated.go","line":2692,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneBorderIndicators","product":"core","slug":"tmux-windowoptionvalues-paneborderindicators"},{"id":"tmux.WindowOptionValues.PaneBorderLines","name":"PaneBorderLines","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneBorderLines]"}],"doc":{"summary":"PaneBorderLines returns materialized \"pane-border-lines\" as [OptionValue] with value type OptionValue[PaneBorderLines] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"single\", \"double\", \"heavy\", \"simple\", \"number\"); CHOICE since tmux 3.6 (choices: \"single\", \"double\", \"heavy\", \"simple\", \"number\", \"spaces\"); set it with [Window.SetPaneBorderLines] or [GlobalWindowScope.SetPaneBorderLines]."},"source":{"file":"tmux/option_generated.go","line":2698,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneBorderLines","product":"core","slug":"tmux-windowoptionvalues-paneborderlines"},{"id":"tmux.WindowOptionValues.PaneBorderStatus","name":"PaneBorderStatus","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneBorderStatus]"}],"doc":{"summary":"PaneBorderStatus returns materialized \"pane-border-status\" as [OptionValue] with value type OptionValue[PaneBorderStatus] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"top\", \"bottom\"); set it with [Window.SetPaneBorderStatus] or [GlobalWindowScope.SetPaneBorderStatus]."},"source":{"file":"tmux/option_generated.go","line":2702,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneBorderStatus","product":"core","slug":"tmux-windowoptionvalues-paneborderstatus"},{"id":"tmux.WindowOptionValues.PaneBorderStyle","name":"PaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneBorderStyle returns materialized \"pane-border-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; STRING since tmux 3.7; set it with [Window.SetPaneBorderStyle] or [GlobalWindowScope.SetPaneBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2709,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneBorderStyle","product":"core","slug":"tmux-windowoptionvalues-paneborderstyle"},{"id":"tmux.WindowOptionValues.PaneColours","name":"PaneColours","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneColours returns materialized \"pane-colours\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window option values; it does not query tmux. Available as COLOUR since tmux 3.3; set it with [Window.SetPaneColours] or [GlobalWindowScope.SetPaneColours]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":2714,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneColours","product":"core","slug":"tmux-windowoptionvalues-panecolours"},{"id":"tmux.WindowOptionValues.PaneScrollbars","name":"PaneScrollbars","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneScrollbars]"}],"doc":{"summary":"PaneScrollbars returns materialized \"pane-scrollbars\" as [OptionValue] with value type OptionValue[PaneScrollbars] from window option values; it does not query tmux. Available as CHOICE since tmux 3.6 (choices: \"off\", \"modal\", \"on\"); set it with [Window.SetPaneScrollbars] or [GlobalWindowScope.SetPaneScrollbars]."},"source":{"file":"tmux/option_generated.go","line":2718,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneScrollbars","product":"core","slug":"tmux-windowoptionvalues-panescrollbars"},{"id":"tmux.WindowOptionValues.PaneScrollbarsPosition","name":"PaneScrollbarsPosition","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PaneScrollbarsPosition]"}],"doc":{"summary":"PaneScrollbarsPosition returns materialized \"pane-scrollbars-position\" as [OptionValue] with value type OptionValue[PaneScrollbarsPosition] from window option values; it does not query tmux. Available as CHOICE since tmux 3.6 (choices: \"right\", \"left\"); set it with [Window.SetPaneScrollbarsPosition] or [GlobalWindowScope.SetPaneScrollbarsPosition]."},"source":{"file":"tmux/option_generated.go","line":2722,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneScrollbarsPosition","product":"core","slug":"tmux-windowoptionvalues-panescrollbarsposition"},{"id":"tmux.WindowOptionValues.PaneScrollbarsStyle","name":"PaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneScrollbarsStyle returns materialized \"pane-scrollbars-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetPaneScrollbarsStyle] or [GlobalWindowScope.SetPaneScrollbarsStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2729,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneScrollbarsStyle","product":"core","slug":"tmux-windowoptionvalues-panescrollbarsstyle"},{"id":"tmux.WindowOptionValues.PaneStatusCurrentStyle","name":"PaneStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneStatusCurrentStyle returns materialized \"pane-status-current-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetPaneStatusCurrentStyle] or [GlobalWindowScope.SetPaneStatusCurrentStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2734,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneStatusCurrentStyle","product":"core","slug":"tmux-windowoptionvalues-panestatuscurrentstyle"},{"id":"tmux.WindowOptionValues.PaneStatusStyle","name":"PaneStatusStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneStatusStyle returns materialized \"pane-status-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetPaneStatusStyle] or [GlobalWindowScope.SetPaneStatusStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2741,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PaneStatusStyle","product":"core","slug":"tmux-windowoptionvalues-panestatusstyle"},{"id":"tmux.WindowOptionValues.PopupBorderLines","name":"PopupBorderLines","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[PopupBorderLines]"}],"doc":{"summary":"PopupBorderLines returns materialized \"popup-border-lines\" as [OptionValue] with value type OptionValue[PopupBorderLines] from window option values; it does not query tmux. Available as CHOICE since tmux 3.3 (choices: \"single\", \"double\", \"heavy\", \"simple\", \"rounded\", \"padded\", \"none\"); set it with [Window.SetPopupBorderLines] or [GlobalWindowScope.SetPopupBorderLines]."},"source":{"file":"tmux/option_generated.go","line":2745,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PopupBorderLines","product":"core","slug":"tmux-windowoptionvalues-popupborderlines"},{"id":"tmux.WindowOptionValues.PopupBorderStyle","name":"PopupBorderStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PopupBorderStyle returns materialized \"popup-border-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Window.SetPopupBorderStyle] or [GlobalWindowScope.SetPopupBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2752,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PopupBorderStyle","product":"core","slug":"tmux-windowoptionvalues-popupborderstyle"},{"id":"tmux.WindowOptionValues.PopupStyle","name":"PopupStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PopupStyle returns materialized \"popup-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Window.SetPopupStyle] or [GlobalWindowScope.SetPopupStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2757,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.PopupStyle","product":"core","slug":"tmux-windowoptionvalues-popupstyle"},{"id":"tmux.WindowOptionValues.RemainOnExit","name":"RemainOnExit","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[RemainOnExit]"}],"doc":{"summary":"RemainOnExit returns materialized \"remain-on-exit\" as [OptionValue] with value type OptionValue[RemainOnExit] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"failed\"); CHOICE since tmux 3.7 (choices: \"off\", \"on\", \"failed\", \"key\"); set it with [Window.SetRemainOnExit] or [GlobalWindowScope.SetRemainOnExit]."},"source":{"file":"tmux/option_generated.go","line":2761,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.RemainOnExit","product":"core","slug":"tmux-windowoptionvalues-remainonexit"},{"id":"tmux.WindowOptionValues.RemainOnExitFormat","name":"RemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"RemainOnExitFormat returns materialized \"remain-on-exit-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Window.SetRemainOnExitFormat] or [GlobalWindowScope.SetRemainOnExitFormat]."},"source":{"file":"tmux/option_generated.go","line":2765,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.RemainOnExitFormat","product":"core","slug":"tmux-windowoptionvalues-remainonexitformat"},{"id":"tmux.WindowOptionValues.ScrollOnClear","name":"ScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"ScrollOnClear returns materialized \"scroll-on-clear\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.3; set it with [Window.SetScrollOnClear] or [GlobalWindowScope.SetScrollOnClear]."},"source":{"file":"tmux/option_generated.go","line":2769,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.ScrollOnClear","product":"core","slug":"tmux-windowoptionvalues-scrollonclear"},{"id":"tmux.WindowOptionValues.SessionStatusCurrentStyle","name":"SessionStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"SessionStatusCurrentStyle returns materialized \"session-status-current-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetSessionStatusCurrentStyle] or [GlobalWindowScope.SetSessionStatusCurrentStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2774,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.SessionStatusCurrentStyle","product":"core","slug":"tmux-windowoptionvalues-sessionstatuscurrentstyle"},{"id":"tmux.WindowOptionValues.SessionStatusStyle","name":"SessionStatusStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"SessionStatusStyle returns materialized \"session-status-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Window.SetSessionStatusStyle] or [GlobalWindowScope.SetSessionStatusStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2781,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.SessionStatusStyle","product":"core","slug":"tmux-windowoptionvalues-sessionstatusstyle"},{"id":"tmux.WindowOptionValues.SynchronizePanes","name":"SynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"SynchronizePanes returns materialized \"synchronize-panes\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetSynchronizePanes] or [GlobalWindowScope.SetSynchronizePanes]."},"source":{"file":"tmux/option_generated.go","line":2785,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.SynchronizePanes","product":"core","slug":"tmux-windowoptionvalues-synchronizepanes"},{"id":"tmux.WindowOptionValues.TiledLayoutMaxColumns","name":"TiledLayoutMaxColumns","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[int64]"}],"doc":{"summary":"TiledLayoutMaxColumns returns materialized \"tiled-layout-max-columns\" as [OptionValue] with value type OptionValue[int64] from window option values; it does not query tmux. Available as NUMBER since tmux 3.6; set it with [Window.SetTiledLayoutMaxColumns] or [GlobalWindowScope.SetTiledLayoutMaxColumns]."},"source":{"file":"tmux/option_generated.go","line":2789,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.TiledLayoutMaxColumns","product":"core","slug":"tmux-windowoptionvalues-tiledlayoutmaxcolumns"},{"id":"tmux.WindowOptionValues.TreeModePreviewFormat","name":"TreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"TreeModePreviewFormat returns materialized \"tree-mode-preview-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetTreeModePreviewFormat] or [GlobalWindowScope.SetTreeModePreviewFormat]."},"source":{"file":"tmux/option_generated.go","line":2795,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.TreeModePreviewFormat","product":"core","slug":"tmux-windowoptionvalues-treemodepreviewformat"},{"id":"tmux.WindowOptionValues.TreeModePreviewStyle","name":"TreeModePreviewStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"TreeModePreviewStyle returns materialized \"tree-mode-preview-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetTreeModePreviewStyle] or [GlobalWindowScope.SetTreeModePreviewStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2802,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.TreeModePreviewStyle","product":"core","slug":"tmux-windowoptionvalues-treemodepreviewstyle"},{"id":"tmux.WindowOptionValues.WindowActiveStyle","name":"WindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowActiveStyle returns materialized \"window-active-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowActiveStyle] or [GlobalWindowScope.SetWindowActiveStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2807,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowActiveStyle","product":"core","slug":"tmux-windowoptionvalues-windowactivestyle"},{"id":"tmux.WindowOptionValues.WindowPaneCurrentStatusFormat","name":"WindowPaneCurrentStatusFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowPaneCurrentStatusFormat returns materialized \"window-pane-current-status-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetWindowPaneCurrentStatusFormat] or [GlobalWindowScope.SetWindowPaneCurrentStatusFormat]."},"source":{"file":"tmux/option_generated.go","line":2811,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowPaneCurrentStatusFormat","product":"core","slug":"tmux-windowoptionvalues-windowpanecurrentstatusformat"},{"id":"tmux.WindowOptionValues.WindowPaneStatusFormat","name":"WindowPaneStatusFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowPaneStatusFormat returns materialized \"window-pane-status-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Window.SetWindowPaneStatusFormat] or [GlobalWindowScope.SetWindowPaneStatusFormat]."},"source":{"file":"tmux/option_generated.go","line":2817,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowPaneStatusFormat","product":"core","slug":"tmux-windowoptionvalues-windowpanestatusformat"},{"id":"tmux.WindowOptionValues.WindowSize","name":"WindowSize","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[WindowSize]"}],"doc":{"summary":"WindowSize returns materialized \"window-size\" as [OptionValue] with value type OptionValue[WindowSize] from window option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"largest\", \"smallest\", \"manual\", \"latest\"); set it with [Window.SetWindowSize] or [GlobalWindowScope.SetWindowSize]."},"source":{"file":"tmux/option_generated.go","line":2823,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowSize","product":"core","slug":"tmux-windowoptionvalues-windowsize"},{"id":"tmux.WindowOptionValues.WindowStatusActivityStyle","name":"WindowStatusActivityStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusActivityStyle returns materialized \"window-status-activity-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusActivityStyle] or [GlobalWindowScope.SetWindowStatusActivityStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2828,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStatusActivityStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatusactivitystyle"},{"id":"tmux.WindowOptionValues.WindowStatusBellStyle","name":"WindowStatusBellStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusBellStyle returns materialized \"window-status-bell-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusBellStyle] or [GlobalWindowScope.SetWindowStatusBellStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2835,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStatusBellStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatusbellstyle"},{"id":"tmux.WindowOptionValues.WindowStatusCurrentFormat","name":"WindowStatusCurrentFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusCurrentFormat returns materialized \"window-status-current-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusCurrentFormat] or [GlobalWindowScope.SetWindowStatusCurrentFormat]."},"source":{"file":"tmux/option_generated.go","line":2841,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStatusCurrentFormat","product":"core","slug":"tmux-windowoptionvalues-windowstatuscurrentformat"},{"id":"tmux.WindowOptionValues.WindowStatusCurrentStyle","name":"WindowStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusCurrentStyle returns materialized \"window-status-current-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusCurrentStyle] or [GlobalWindowScope.SetWindowStatusCurrentStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2848,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStatusCurrentStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatuscurrentstyle"},{"id":"tmux.WindowOptionValues.WindowStatusFormat","name":"WindowStatusFormat","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusFormat returns materialized \"window-status-format\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusFormat] or [GlobalWindowScope.SetWindowStatusFormat]."},"source":{"file":"tmux/option_generated.go","line":2854,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStatusFormat","product":"core","slug":"tmux-windowoptionvalues-windowstatusformat"},{"id":"tmux.WindowOptionValues.WindowStatusLastStyle","name":"WindowStatusLastStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusLastStyle returns materialized \"window-status-last-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusLastStyle] or [GlobalWindowScope.SetWindowStatusLastStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2859,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStatusLastStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatuslaststyle"},{"id":"tmux.WindowOptionValues.WindowStatusSeparator","name":"WindowStatusSeparator","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusSeparator returns materialized \"window-status-separator\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusSeparator] or [GlobalWindowScope.SetWindowStatusSeparator]."},"source":{"file":"tmux/option_generated.go","line":2865,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStatusSeparator","product":"core","slug":"tmux-windowoptionvalues-windowstatusseparator"},{"id":"tmux.WindowOptionValues.WindowStatusStyle","name":"WindowStatusStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStatusStyle returns materialized \"window-status-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStatusStyle] or [GlobalWindowScope.SetWindowStatusStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2872,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStatusStyle","product":"core","slug":"tmux-windowoptionvalues-windowstatusstyle"},{"id":"tmux.WindowOptionValues.WindowStyle","name":"WindowStyle","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStyle returns materialized \"window-style\" as [OptionValue] with value type OptionValue[string] from window option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Window.SetWindowStyle] or [GlobalWindowScope.SetWindowStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":2877,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WindowStyle","product":"core","slug":"tmux-windowoptionvalues-windowstyle"},{"id":"tmux.WindowOptionValues.WrapSearch","name":"WrapSearch","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"WrapSearch returns materialized \"wrap-search\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetWrapSearch] or [GlobalWindowScope.SetWrapSearch]."},"source":{"file":"tmux/option_generated.go","line":2881,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.WrapSearch","product":"core","slug":"tmux-windowoptionvalues-wrapsearch"},{"id":"tmux.WindowOptionValues.XTermKeys","name":"XTermKeys","kind":"method","modifiers":[],"parent":"tmux.WindowOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"XTermKeys returns materialized \"xterm-keys\" as [OptionValue] with value type OptionValue[bool] from window option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Window.SetXTermKeys] or [GlobalWindowScope.SetXTermKeys]."},"source":{"file":"tmux/option_generated.go","line":2885,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowOptionValues.XTermKeys","product":"core","slug":"tmux-windowoptionvalues-xtermkeys"},{"id":"tmux.PaneOptionValues","name":"PaneOptionValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneOptionValues is an immutable materialized view of known pane option values; its zero value is empty and it does not refresh. Obtain it with [Pane.Options]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Pane.RawOption] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":3047,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues","product":"core","slug":"tmux-paneoptionvalues"},{"id":"tmux.PaneOptionValues.AllowPassthrough","name":"AllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[AllowPassthrough]"}],"doc":{"summary":"AllowPassthrough returns materialized \"allow-passthrough\" as [OptionValue] with value type OptionValue[AllowPassthrough] from pane option values; it does not query tmux. Available as FLAG since tmux 3.3; CHOICE since tmux 3.4 (choices: \"off\", \"on\", \"all\"); set it with [Pane.SetAllowPassthrough]."},"source":{"file":"tmux/option_generated.go","line":3071,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.AllowPassthrough","product":"core","slug":"tmux-paneoptionvalues-allowpassthrough"},{"id":"tmux.PaneOptionValues.AllowRename","name":"AllowRename","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AllowRename returns materialized \"allow-rename\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Pane.SetAllowRename]."},"source":{"file":"tmux/option_generated.go","line":3075,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.AllowRename","product":"core","slug":"tmux-paneoptionvalues-allowrename"},{"id":"tmux.PaneOptionValues.AllowSetTitle","name":"AllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AllowSetTitle returns materialized \"allow-set-title\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.5; set it with [Pane.SetAllowSetTitle]."},"source":{"file":"tmux/option_generated.go","line":3079,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.AllowSetTitle","product":"core","slug":"tmux-paneoptionvalues-allowsettitle"},{"id":"tmux.PaneOptionValues.AlternateScreen","name":"AlternateScreen","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"AlternateScreen returns materialized \"alternate-screen\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Pane.SetAlternateScreen]."},"source":{"file":"tmux/option_generated.go","line":3083,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.AlternateScreen","product":"core","slug":"tmux-paneoptionvalues-alternatescreen"},{"id":"tmux.PaneOptionValues.CopyModePositionFormat","name":"CopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CopyModePositionFormat returns materialized \"copy-mode-position-format\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Pane.SetCopyModePositionFormat]."},"source":{"file":"tmux/option_generated.go","line":3087,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.CopyModePositionFormat","product":"core","slug":"tmux-paneoptionvalues-copymodepositionformat"},{"id":"tmux.PaneOptionValues.CursorColour","name":"CursorColour","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"CursorColour returns materialized \"cursor-colour\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as COLOUR since tmux 3.3; set it with [Pane.SetCursorColour]."},"source":{"file":"tmux/option_generated.go","line":3093,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.CursorColour","product":"core","slug":"tmux-paneoptionvalues-cursorcolour"},{"id":"tmux.PaneOptionValues.CursorStyle","name":"CursorStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[CursorStyle]"}],"doc":{"summary":"CursorStyle returns materialized \"cursor-style\" as [OptionValue] with value type OptionValue[CursorStyle] from pane option values; it does not query tmux. Available as CHOICE since tmux 3.3 (choices: \"default\", \"blinking-block\", \"block\", \"blinking-underline\", \"underline\", \"blinking-bar\", \"bar\"); set it with [Pane.SetCursorStyle]."},"source":{"file":"tmux/option_generated.go","line":3097,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.CursorStyle","product":"core","slug":"tmux-paneoptionvalues-cursorstyle"},{"id":"tmux.PaneOptionValues.PaneActiveBorderStyle","name":"PaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneActiveBorderStyle returns materialized \"pane-active-border-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Pane.SetPaneActiveBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.PaneActiveBorderStyle","product":"core","slug":"tmux-paneoptionvalues-paneactiveborderstyle"},{"id":"tmux.PaneOptionValues.PaneBorderFormat","name":"PaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneBorderFormat returns materialized \"pane-border-format\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Pane.SetPaneBorderFormat]."},"source":{"file":"tmux/option_generated.go","line":3106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.PaneBorderFormat","product":"core","slug":"tmux-paneoptionvalues-paneborderformat"},{"id":"tmux.PaneOptionValues.PaneBorderStyle","name":"PaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneBorderStyle returns materialized \"pane-border-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Pane.SetPaneBorderStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.PaneBorderStyle","product":"core","slug":"tmux-paneoptionvalues-paneborderstyle"},{"id":"tmux.PaneOptionValues.PaneColours","name":"PaneColours","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneColours returns materialized \"pane-colours\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane option values; it does not query tmux. Available as COLOUR since tmux 3.3; set it with [Pane.SetPaneColours]. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3116,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.PaneColours","product":"core","slug":"tmux-paneoptionvalues-panecolours"},{"id":"tmux.PaneOptionValues.PaneScrollbarsStyle","name":"PaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"PaneScrollbarsStyle returns materialized \"pane-scrollbars-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.6; set it with [Pane.SetPaneScrollbarsStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3121,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.PaneScrollbarsStyle","product":"core","slug":"tmux-paneoptionvalues-panescrollbarsstyle"},{"id":"tmux.PaneOptionValues.RemainOnExit","name":"RemainOnExit","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[RemainOnExit]"}],"doc":{"summary":"RemainOnExit returns materialized \"remain-on-exit\" as [OptionValue] with value type OptionValue[RemainOnExit] from pane option values; it does not query tmux. Available as CHOICE since tmux 3.2a (choices: \"off\", \"on\", \"failed\"); CHOICE since tmux 3.7 (choices: \"off\", \"on\", \"failed\", \"key\"); set it with [Pane.SetRemainOnExit]."},"source":{"file":"tmux/option_generated.go","line":3125,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.RemainOnExit","product":"core","slug":"tmux-paneoptionvalues-remainonexit"},{"id":"tmux.PaneOptionValues.RemainOnExitFormat","name":"RemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"RemainOnExitFormat returns materialized \"remain-on-exit-format\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.3; set it with [Pane.SetRemainOnExitFormat]."},"source":{"file":"tmux/option_generated.go","line":3129,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.RemainOnExitFormat","product":"core","slug":"tmux-paneoptionvalues-remainonexitformat"},{"id":"tmux.PaneOptionValues.ScrollOnClear","name":"ScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"ScrollOnClear returns materialized \"scroll-on-clear\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.3; set it with [Pane.SetScrollOnClear]."},"source":{"file":"tmux/option_generated.go","line":3133,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.ScrollOnClear","product":"core","slug":"tmux-paneoptionvalues-scrollonclear"},{"id":"tmux.PaneOptionValues.SynchronizePanes","name":"SynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[bool]"}],"doc":{"summary":"SynchronizePanes returns materialized \"synchronize-panes\" as [OptionValue] with value type OptionValue[bool] from pane option values; it does not query tmux. Available as FLAG since tmux 3.2a; set it with [Pane.SetSynchronizePanes]."},"source":{"file":"tmux/option_generated.go","line":3137,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.SynchronizePanes","product":"core","slug":"tmux-paneoptionvalues-synchronizepanes"},{"id":"tmux.PaneOptionValues.TreeModePreviewFormat","name":"TreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"TreeModePreviewFormat returns materialized \"tree-mode-preview-format\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.7; set it with [Pane.SetTreeModePreviewFormat]."},"source":{"file":"tmux/option_generated.go","line":3141,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.TreeModePreviewFormat","product":"core","slug":"tmux-paneoptionvalues-treemodepreviewformat"},{"id":"tmux.PaneOptionValues.WindowActiveStyle","name":"WindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowActiveStyle returns materialized \"window-active-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Pane.SetWindowActiveStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3146,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.WindowActiveStyle","product":"core","slug":"tmux-paneoptionvalues-windowactivestyle"},{"id":"tmux.PaneOptionValues.WindowStyle","name":"WindowStyle","kind":"method","modifiers":[],"parent":"tmux.PaneOptionValues","signatures":[{"params":[],"returns":"OptionValue[string]"}],"doc":{"summary":"WindowStyle returns materialized \"window-style\" as [OptionValue] with value type OptionValue[string] from pane option values; it does not query tmux. Available as STRING since tmux 3.2a; set it with [Pane.SetWindowStyle]. It is a style option."},"source":{"file":"tmux/option_generated.go","line":3151,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneOptionValues.WindowStyle","product":"core","slug":"tmux-paneoptionvalues-windowstyle"},{"id":"tmux.ServerHookValues","name":"ServerHookValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerHookValues is an immutable materialized view of known global session-scope hook values; its zero value is empty and it does not refresh. Obtain it with [GlobalSessionScope.Hooks]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [GlobalSessionScope.RawHook] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":3203,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues","product":"core","slug":"tmux-serverhookvalues"},{"id":"tmux.ServerHookValues.AfterBindKey","name":"AfterBindKey","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterBindKey returns materialized \"after-bind-key\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3266,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterBindKey","product":"core","slug":"tmux-serverhookvalues-afterbindkey"},{"id":"tmux.ServerHookValues.AfterCapturePane","name":"AfterCapturePane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterCapturePane returns materialized \"after-capture-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3271,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterCapturePane","product":"core","slug":"tmux-serverhookvalues-aftercapturepane"},{"id":"tmux.ServerHookValues.AfterCopyMode","name":"AfterCopyMode","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterCopyMode returns materialized \"after-copy-mode\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3278,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterCopyMode","product":"core","slug":"tmux-serverhookvalues-aftercopymode"},{"id":"tmux.ServerHookValues.AfterDisplayMessage","name":"AfterDisplayMessage","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterDisplayMessage returns materialized \"after-display-message\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3283,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterDisplayMessage","product":"core","slug":"tmux-serverhookvalues-afterdisplaymessage"},{"id":"tmux.ServerHookValues.AfterDisplayPanes","name":"AfterDisplayPanes","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterDisplayPanes returns materialized \"after-display-panes\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3290,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterDisplayPanes","product":"core","slug":"tmux-serverhookvalues-afterdisplaypanes"},{"id":"tmux.ServerHookValues.AfterKillPane","name":"AfterKillPane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterKillPane returns materialized \"after-kill-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3297,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterKillPane","product":"core","slug":"tmux-serverhookvalues-afterkillpane"},{"id":"tmux.ServerHookValues.AfterListBuffers","name":"AfterListBuffers","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListBuffers returns materialized \"after-list-buffers\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3302,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterListBuffers","product":"core","slug":"tmux-serverhookvalues-afterlistbuffers"},{"id":"tmux.ServerHookValues.AfterListClients","name":"AfterListClients","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListClients returns materialized \"after-list-clients\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3309,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterListClients","product":"core","slug":"tmux-serverhookvalues-afterlistclients"},{"id":"tmux.ServerHookValues.AfterListKeys","name":"AfterListKeys","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListKeys returns materialized \"after-list-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3316,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterListKeys","product":"core","slug":"tmux-serverhookvalues-afterlistkeys"},{"id":"tmux.ServerHookValues.AfterListPanes","name":"AfterListPanes","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListPanes returns materialized \"after-list-panes\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3321,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterListPanes","product":"core","slug":"tmux-serverhookvalues-afterlistpanes"},{"id":"tmux.ServerHookValues.AfterListSessions","name":"AfterListSessions","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListSessions returns materialized \"after-list-sessions\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3326,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterListSessions","product":"core","slug":"tmux-serverhookvalues-afterlistsessions"},{"id":"tmux.ServerHookValues.AfterListWindows","name":"AfterListWindows","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListWindows returns materialized \"after-list-windows\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3333,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterListWindows","product":"core","slug":"tmux-serverhookvalues-afterlistwindows"},{"id":"tmux.ServerHookValues.AfterLoadBuffer","name":"AfterLoadBuffer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterLoadBuffer returns materialized \"after-load-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3340,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterLoadBuffer","product":"core","slug":"tmux-serverhookvalues-afterloadbuffer"},{"id":"tmux.ServerHookValues.AfterLockServer","name":"AfterLockServer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterLockServer returns materialized \"after-lock-server\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3347,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterLockServer","product":"core","slug":"tmux-serverhookvalues-afterlockserver"},{"id":"tmux.ServerHookValues.AfterNewSession","name":"AfterNewSession","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterNewSession returns materialized \"after-new-session\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3354,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterNewSession","product":"core","slug":"tmux-serverhookvalues-afternewsession"},{"id":"tmux.ServerHookValues.AfterNewWindow","name":"AfterNewWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterNewWindow returns materialized \"after-new-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3361,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterNewWindow","product":"core","slug":"tmux-serverhookvalues-afternewwindow"},{"id":"tmux.ServerHookValues.AfterPasteBuffer","name":"AfterPasteBuffer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterPasteBuffer returns materialized \"after-paste-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3366,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterPasteBuffer","product":"core","slug":"tmux-serverhookvalues-afterpastebuffer"},{"id":"tmux.ServerHookValues.AfterPipePane","name":"AfterPipePane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterPipePane returns materialized \"after-pipe-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3373,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterPipePane","product":"core","slug":"tmux-serverhookvalues-afterpipepane"},{"id":"tmux.ServerHookValues.AfterQueue","name":"AfterQueue","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterQueue returns materialized \"after-queue\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3378,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterQueue","product":"core","slug":"tmux-serverhookvalues-afterqueue"},{"id":"tmux.ServerHookValues.AfterRefreshClient","name":"AfterRefreshClient","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRefreshClient returns materialized \"after-refresh-client\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3383,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterRefreshClient","product":"core","slug":"tmux-serverhookvalues-afterrefreshclient"},{"id":"tmux.ServerHookValues.AfterRenameSession","name":"AfterRenameSession","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRenameSession returns materialized \"after-rename-session\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3390,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterRenameSession","product":"core","slug":"tmux-serverhookvalues-afterrenamesession"},{"id":"tmux.ServerHookValues.AfterRenameWindow","name":"AfterRenameWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRenameWindow returns materialized \"after-rename-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3397,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterRenameWindow","product":"core","slug":"tmux-serverhookvalues-afterrenamewindow"},{"id":"tmux.ServerHookValues.AfterResizePane","name":"AfterResizePane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterResizePane returns materialized \"after-resize-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3404,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterResizePane","product":"core","slug":"tmux-serverhookvalues-afterresizepane"},{"id":"tmux.ServerHookValues.AfterResizeWindow","name":"AfterResizeWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterResizeWindow returns materialized \"after-resize-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3411,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterResizeWindow","product":"core","slug":"tmux-serverhookvalues-afterresizewindow"},{"id":"tmux.ServerHookValues.AfterSaveBuffer","name":"AfterSaveBuffer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSaveBuffer returns materialized \"after-save-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3418,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSaveBuffer","product":"core","slug":"tmux-serverhookvalues-aftersavebuffer"},{"id":"tmux.ServerHookValues.AfterSelectLayout","name":"AfterSelectLayout","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectLayout returns materialized \"after-select-layout\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3425,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSelectLayout","product":"core","slug":"tmux-serverhookvalues-afterselectlayout"},{"id":"tmux.ServerHookValues.AfterSelectPane","name":"AfterSelectPane","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectPane returns materialized \"after-select-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3432,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSelectPane","product":"core","slug":"tmux-serverhookvalues-afterselectpane"},{"id":"tmux.ServerHookValues.AfterSelectWindow","name":"AfterSelectWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectWindow returns materialized \"after-select-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3439,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSelectWindow","product":"core","slug":"tmux-serverhookvalues-afterselectwindow"},{"id":"tmux.ServerHookValues.AfterSendKeys","name":"AfterSendKeys","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSendKeys returns materialized \"after-send-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3446,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSendKeys","product":"core","slug":"tmux-serverhookvalues-aftersendkeys"},{"id":"tmux.ServerHookValues.AfterSetBuffer","name":"AfterSetBuffer","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetBuffer returns materialized \"after-set-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3451,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSetBuffer","product":"core","slug":"tmux-serverhookvalues-aftersetbuffer"},{"id":"tmux.ServerHookValues.AfterSetEnvironment","name":"AfterSetEnvironment","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetEnvironment returns materialized \"after-set-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3456,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSetEnvironment","product":"core","slug":"tmux-serverhookvalues-aftersetenvironment"},{"id":"tmux.ServerHookValues.AfterSetHook","name":"AfterSetHook","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetHook returns materialized \"after-set-hook\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3463,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSetHook","product":"core","slug":"tmux-serverhookvalues-aftersethook"},{"id":"tmux.ServerHookValues.AfterSetOption","name":"AfterSetOption","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetOption returns materialized \"after-set-option\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3468,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSetOption","product":"core","slug":"tmux-serverhookvalues-aftersetoption"},{"id":"tmux.ServerHookValues.AfterShowEnvironment","name":"AfterShowEnvironment","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowEnvironment returns materialized \"after-show-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3473,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterShowEnvironment","product":"core","slug":"tmux-serverhookvalues-aftershowenvironment"},{"id":"tmux.ServerHookValues.AfterShowMessages","name":"AfterShowMessages","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowMessages returns materialized \"after-show-messages\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3480,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterShowMessages","product":"core","slug":"tmux-serverhookvalues-aftershowmessages"},{"id":"tmux.ServerHookValues.AfterShowOptions","name":"AfterShowOptions","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowOptions returns materialized \"after-show-options\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3487,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterShowOptions","product":"core","slug":"tmux-serverhookvalues-aftershowoptions"},{"id":"tmux.ServerHookValues.AfterSplitWindow","name":"AfterSplitWindow","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSplitWindow returns materialized \"after-split-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3494,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterSplitWindow","product":"core","slug":"tmux-serverhookvalues-aftersplitwindow"},{"id":"tmux.ServerHookValues.AfterUnbindKey","name":"AfterUnbindKey","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterUnbindKey returns materialized \"after-unbind-key\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3501,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AfterUnbindKey","product":"core","slug":"tmux-serverhookvalues-afterunbindkey"},{"id":"tmux.ServerHookValues.AlertActivity","name":"AlertActivity","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertActivity returns materialized \"alert-activity\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3506,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AlertActivity","product":"core","slug":"tmux-serverhookvalues-alertactivity"},{"id":"tmux.ServerHookValues.AlertBell","name":"AlertBell","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertBell returns materialized \"alert-bell\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3511,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AlertBell","product":"core","slug":"tmux-serverhookvalues-alertbell"},{"id":"tmux.ServerHookValues.AlertSilence","name":"AlertSilence","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertSilence returns materialized \"alert-silence\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3516,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.AlertSilence","product":"core","slug":"tmux-serverhookvalues-alertsilence"},{"id":"tmux.ServerHookValues.ClientActive","name":"ClientActive","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientActive returns materialized \"client-active\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3521,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientActive","product":"core","slug":"tmux-serverhookvalues-clientactive"},{"id":"tmux.ServerHookValues.ClientAttached","name":"ClientAttached","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientAttached returns materialized \"client-attached\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3526,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientAttached","product":"core","slug":"tmux-serverhookvalues-clientattached"},{"id":"tmux.ServerHookValues.ClientDarkTheme","name":"ClientDarkTheme","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientDarkTheme returns materialized \"client-dark-theme\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.6. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3531,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientDarkTheme","product":"core","slug":"tmux-serverhookvalues-clientdarktheme"},{"id":"tmux.ServerHookValues.ClientDetached","name":"ClientDetached","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientDetached returns materialized \"client-detached\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3538,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientDetached","product":"core","slug":"tmux-serverhookvalues-clientdetached"},{"id":"tmux.ServerHookValues.ClientFocusIn","name":"ClientFocusIn","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientFocusIn returns materialized \"client-focus-in\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3543,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientFocusIn","product":"core","slug":"tmux-serverhookvalues-clientfocusin"},{"id":"tmux.ServerHookValues.ClientFocusOut","name":"ClientFocusOut","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientFocusOut returns materialized \"client-focus-out\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3548,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientFocusOut","product":"core","slug":"tmux-serverhookvalues-clientfocusout"},{"id":"tmux.ServerHookValues.ClientLightTheme","name":"ClientLightTheme","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientLightTheme returns materialized \"client-light-theme\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.6. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3553,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientLightTheme","product":"core","slug":"tmux-serverhookvalues-clientlighttheme"},{"id":"tmux.ServerHookValues.ClientResized","name":"ClientResized","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientResized returns materialized \"client-resized\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3560,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientResized","product":"core","slug":"tmux-serverhookvalues-clientresized"},{"id":"tmux.ServerHookValues.ClientSessionChanged","name":"ClientSessionChanged","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientSessionChanged returns materialized \"client-session-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3565,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.ClientSessionChanged","product":"core","slug":"tmux-serverhookvalues-clientsessionchanged"},{"id":"tmux.ServerHookValues.CommandError","name":"CommandError","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"CommandError returns materialized \"command-error\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.5. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3572,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.CommandError","product":"core","slug":"tmux-serverhookvalues-commanderror"},{"id":"tmux.ServerHookValues.SessionClosed","name":"SessionClosed","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionClosed returns materialized \"session-closed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3577,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.SessionClosed","product":"core","slug":"tmux-serverhookvalues-sessionclosed"},{"id":"tmux.ServerHookValues.SessionCreated","name":"SessionCreated","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionCreated returns materialized \"session-created\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3582,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.SessionCreated","product":"core","slug":"tmux-serverhookvalues-sessioncreated"},{"id":"tmux.ServerHookValues.SessionRenamed","name":"SessionRenamed","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionRenamed returns materialized \"session-renamed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3587,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.SessionRenamed","product":"core","slug":"tmux-serverhookvalues-sessionrenamed"},{"id":"tmux.ServerHookValues.SessionWindowChanged","name":"SessionWindowChanged","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionWindowChanged returns materialized \"session-window-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3592,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.SessionWindowChanged","product":"core","slug":"tmux-serverhookvalues-sessionwindowchanged"},{"id":"tmux.ServerHookValues.WindowLinked","name":"WindowLinked","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowLinked returns materialized \"window-linked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3599,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.WindowLinked","product":"core","slug":"tmux-serverhookvalues-windowlinked"},{"id":"tmux.ServerHookValues.WindowUnlinked","name":"WindowUnlinked","kind":"method","modifiers":[],"parent":"tmux.ServerHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowUnlinked returns materialized \"window-unlinked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from global session-scope hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3604,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerHookValues.WindowUnlinked","product":"core","slug":"tmux-serverhookvalues-windowunlinked"},{"id":"tmux.SessionHookValues","name":"SessionHookValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SessionHookValues is an immutable materialized view of known session hook values; its zero value is empty and it does not refresh. Obtain it with [Session.Hooks]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Session.RawHook] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":3732,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues","product":"core","slug":"tmux-sessionhookvalues"},{"id":"tmux.SessionHookValues.AfterBindKey","name":"AfterBindKey","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterBindKey returns materialized \"after-bind-key\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3795,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterBindKey","product":"core","slug":"tmux-sessionhookvalues-afterbindkey"},{"id":"tmux.SessionHookValues.AfterCapturePane","name":"AfterCapturePane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterCapturePane returns materialized \"after-capture-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3800,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterCapturePane","product":"core","slug":"tmux-sessionhookvalues-aftercapturepane"},{"id":"tmux.SessionHookValues.AfterCopyMode","name":"AfterCopyMode","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterCopyMode returns materialized \"after-copy-mode\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3807,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterCopyMode","product":"core","slug":"tmux-sessionhookvalues-aftercopymode"},{"id":"tmux.SessionHookValues.AfterDisplayMessage","name":"AfterDisplayMessage","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterDisplayMessage returns materialized \"after-display-message\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3812,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterDisplayMessage","product":"core","slug":"tmux-sessionhookvalues-afterdisplaymessage"},{"id":"tmux.SessionHookValues.AfterDisplayPanes","name":"AfterDisplayPanes","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterDisplayPanes returns materialized \"after-display-panes\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3819,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterDisplayPanes","product":"core","slug":"tmux-sessionhookvalues-afterdisplaypanes"},{"id":"tmux.SessionHookValues.AfterKillPane","name":"AfterKillPane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterKillPane returns materialized \"after-kill-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3826,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterKillPane","product":"core","slug":"tmux-sessionhookvalues-afterkillpane"},{"id":"tmux.SessionHookValues.AfterListBuffers","name":"AfterListBuffers","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListBuffers returns materialized \"after-list-buffers\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3831,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterListBuffers","product":"core","slug":"tmux-sessionhookvalues-afterlistbuffers"},{"id":"tmux.SessionHookValues.AfterListClients","name":"AfterListClients","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListClients returns materialized \"after-list-clients\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3838,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterListClients","product":"core","slug":"tmux-sessionhookvalues-afterlistclients"},{"id":"tmux.SessionHookValues.AfterListKeys","name":"AfterListKeys","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListKeys returns materialized \"after-list-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3845,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterListKeys","product":"core","slug":"tmux-sessionhookvalues-afterlistkeys"},{"id":"tmux.SessionHookValues.AfterListPanes","name":"AfterListPanes","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListPanes returns materialized \"after-list-panes\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3850,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterListPanes","product":"core","slug":"tmux-sessionhookvalues-afterlistpanes"},{"id":"tmux.SessionHookValues.AfterListSessions","name":"AfterListSessions","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListSessions returns materialized \"after-list-sessions\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3855,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterListSessions","product":"core","slug":"tmux-sessionhookvalues-afterlistsessions"},{"id":"tmux.SessionHookValues.AfterListWindows","name":"AfterListWindows","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterListWindows returns materialized \"after-list-windows\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3862,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterListWindows","product":"core","slug":"tmux-sessionhookvalues-afterlistwindows"},{"id":"tmux.SessionHookValues.AfterLoadBuffer","name":"AfterLoadBuffer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterLoadBuffer returns materialized \"after-load-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3869,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterLoadBuffer","product":"core","slug":"tmux-sessionhookvalues-afterloadbuffer"},{"id":"tmux.SessionHookValues.AfterLockServer","name":"AfterLockServer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterLockServer returns materialized \"after-lock-server\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3876,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterLockServer","product":"core","slug":"tmux-sessionhookvalues-afterlockserver"},{"id":"tmux.SessionHookValues.AfterNewSession","name":"AfterNewSession","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterNewSession returns materialized \"after-new-session\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3883,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterNewSession","product":"core","slug":"tmux-sessionhookvalues-afternewsession"},{"id":"tmux.SessionHookValues.AfterNewWindow","name":"AfterNewWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterNewWindow returns materialized \"after-new-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3890,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterNewWindow","product":"core","slug":"tmux-sessionhookvalues-afternewwindow"},{"id":"tmux.SessionHookValues.AfterPasteBuffer","name":"AfterPasteBuffer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterPasteBuffer returns materialized \"after-paste-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3895,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterPasteBuffer","product":"core","slug":"tmux-sessionhookvalues-afterpastebuffer"},{"id":"tmux.SessionHookValues.AfterPipePane","name":"AfterPipePane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterPipePane returns materialized \"after-pipe-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3902,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterPipePane","product":"core","slug":"tmux-sessionhookvalues-afterpipepane"},{"id":"tmux.SessionHookValues.AfterQueue","name":"AfterQueue","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterQueue returns materialized \"after-queue\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3907,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterQueue","product":"core","slug":"tmux-sessionhookvalues-afterqueue"},{"id":"tmux.SessionHookValues.AfterRefreshClient","name":"AfterRefreshClient","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRefreshClient returns materialized \"after-refresh-client\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3912,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterRefreshClient","product":"core","slug":"tmux-sessionhookvalues-afterrefreshclient"},{"id":"tmux.SessionHookValues.AfterRenameSession","name":"AfterRenameSession","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRenameSession returns materialized \"after-rename-session\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3919,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterRenameSession","product":"core","slug":"tmux-sessionhookvalues-afterrenamesession"},{"id":"tmux.SessionHookValues.AfterRenameWindow","name":"AfterRenameWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterRenameWindow returns materialized \"after-rename-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3926,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterRenameWindow","product":"core","slug":"tmux-sessionhookvalues-afterrenamewindow"},{"id":"tmux.SessionHookValues.AfterResizePane","name":"AfterResizePane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterResizePane returns materialized \"after-resize-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3933,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterResizePane","product":"core","slug":"tmux-sessionhookvalues-afterresizepane"},{"id":"tmux.SessionHookValues.AfterResizeWindow","name":"AfterResizeWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterResizeWindow returns materialized \"after-resize-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3940,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterResizeWindow","product":"core","slug":"tmux-sessionhookvalues-afterresizewindow"},{"id":"tmux.SessionHookValues.AfterSaveBuffer","name":"AfterSaveBuffer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSaveBuffer returns materialized \"after-save-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3947,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSaveBuffer","product":"core","slug":"tmux-sessionhookvalues-aftersavebuffer"},{"id":"tmux.SessionHookValues.AfterSelectLayout","name":"AfterSelectLayout","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectLayout returns materialized \"after-select-layout\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3954,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSelectLayout","product":"core","slug":"tmux-sessionhookvalues-afterselectlayout"},{"id":"tmux.SessionHookValues.AfterSelectPane","name":"AfterSelectPane","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectPane returns materialized \"after-select-pane\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3961,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSelectPane","product":"core","slug":"tmux-sessionhookvalues-afterselectpane"},{"id":"tmux.SessionHookValues.AfterSelectWindow","name":"AfterSelectWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSelectWindow returns materialized \"after-select-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3968,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSelectWindow","product":"core","slug":"tmux-sessionhookvalues-afterselectwindow"},{"id":"tmux.SessionHookValues.AfterSendKeys","name":"AfterSendKeys","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSendKeys returns materialized \"after-send-keys\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3975,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSendKeys","product":"core","slug":"tmux-sessionhookvalues-aftersendkeys"},{"id":"tmux.SessionHookValues.AfterSetBuffer","name":"AfterSetBuffer","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetBuffer returns materialized \"after-set-buffer\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3980,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSetBuffer","product":"core","slug":"tmux-sessionhookvalues-aftersetbuffer"},{"id":"tmux.SessionHookValues.AfterSetEnvironment","name":"AfterSetEnvironment","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetEnvironment returns materialized \"after-set-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3985,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSetEnvironment","product":"core","slug":"tmux-sessionhookvalues-aftersetenvironment"},{"id":"tmux.SessionHookValues.AfterSetHook","name":"AfterSetHook","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetHook returns materialized \"after-set-hook\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3992,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSetHook","product":"core","slug":"tmux-sessionhookvalues-aftersethook"},{"id":"tmux.SessionHookValues.AfterSetOption","name":"AfterSetOption","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSetOption returns materialized \"after-set-option\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":3997,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSetOption","product":"core","slug":"tmux-sessionhookvalues-aftersetoption"},{"id":"tmux.SessionHookValues.AfterShowEnvironment","name":"AfterShowEnvironment","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowEnvironment returns materialized \"after-show-environment\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4002,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterShowEnvironment","product":"core","slug":"tmux-sessionhookvalues-aftershowenvironment"},{"id":"tmux.SessionHookValues.AfterShowMessages","name":"AfterShowMessages","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowMessages returns materialized \"after-show-messages\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4009,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterShowMessages","product":"core","slug":"tmux-sessionhookvalues-aftershowmessages"},{"id":"tmux.SessionHookValues.AfterShowOptions","name":"AfterShowOptions","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterShowOptions returns materialized \"after-show-options\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4016,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterShowOptions","product":"core","slug":"tmux-sessionhookvalues-aftershowoptions"},{"id":"tmux.SessionHookValues.AfterSplitWindow","name":"AfterSplitWindow","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterSplitWindow returns materialized \"after-split-window\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4023,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterSplitWindow","product":"core","slug":"tmux-sessionhookvalues-aftersplitwindow"},{"id":"tmux.SessionHookValues.AfterUnbindKey","name":"AfterUnbindKey","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AfterUnbindKey returns materialized \"after-unbind-key\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4030,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AfterUnbindKey","product":"core","slug":"tmux-sessionhookvalues-afterunbindkey"},{"id":"tmux.SessionHookValues.AlertActivity","name":"AlertActivity","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertActivity returns materialized \"alert-activity\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4035,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AlertActivity","product":"core","slug":"tmux-sessionhookvalues-alertactivity"},{"id":"tmux.SessionHookValues.AlertBell","name":"AlertBell","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertBell returns materialized \"alert-bell\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4040,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AlertBell","product":"core","slug":"tmux-sessionhookvalues-alertbell"},{"id":"tmux.SessionHookValues.AlertSilence","name":"AlertSilence","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"AlertSilence returns materialized \"alert-silence\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4045,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.AlertSilence","product":"core","slug":"tmux-sessionhookvalues-alertsilence"},{"id":"tmux.SessionHookValues.ClientActive","name":"ClientActive","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientActive returns materialized \"client-active\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4050,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientActive","product":"core","slug":"tmux-sessionhookvalues-clientactive"},{"id":"tmux.SessionHookValues.ClientAttached","name":"ClientAttached","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientAttached returns materialized \"client-attached\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4055,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientAttached","product":"core","slug":"tmux-sessionhookvalues-clientattached"},{"id":"tmux.SessionHookValues.ClientDarkTheme","name":"ClientDarkTheme","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientDarkTheme returns materialized \"client-dark-theme\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.6. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4060,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientDarkTheme","product":"core","slug":"tmux-sessionhookvalues-clientdarktheme"},{"id":"tmux.SessionHookValues.ClientDetached","name":"ClientDetached","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientDetached returns materialized \"client-detached\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4067,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientDetached","product":"core","slug":"tmux-sessionhookvalues-clientdetached"},{"id":"tmux.SessionHookValues.ClientFocusIn","name":"ClientFocusIn","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientFocusIn returns materialized \"client-focus-in\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4072,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientFocusIn","product":"core","slug":"tmux-sessionhookvalues-clientfocusin"},{"id":"tmux.SessionHookValues.ClientFocusOut","name":"ClientFocusOut","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientFocusOut returns materialized \"client-focus-out\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4077,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientFocusOut","product":"core","slug":"tmux-sessionhookvalues-clientfocusout"},{"id":"tmux.SessionHookValues.ClientLightTheme","name":"ClientLightTheme","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientLightTheme returns materialized \"client-light-theme\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.6. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4082,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientLightTheme","product":"core","slug":"tmux-sessionhookvalues-clientlighttheme"},{"id":"tmux.SessionHookValues.ClientResized","name":"ClientResized","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientResized returns materialized \"client-resized\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4089,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientResized","product":"core","slug":"tmux-sessionhookvalues-clientresized"},{"id":"tmux.SessionHookValues.ClientSessionChanged","name":"ClientSessionChanged","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"ClientSessionChanged returns materialized \"client-session-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4094,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.ClientSessionChanged","product":"core","slug":"tmux-sessionhookvalues-clientsessionchanged"},{"id":"tmux.SessionHookValues.CommandError","name":"CommandError","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"CommandError returns materialized \"command-error\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.5. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4101,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.CommandError","product":"core","slug":"tmux-sessionhookvalues-commanderror"},{"id":"tmux.SessionHookValues.SessionClosed","name":"SessionClosed","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionClosed returns materialized \"session-closed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.SessionClosed","product":"core","slug":"tmux-sessionhookvalues-sessionclosed"},{"id":"tmux.SessionHookValues.SessionCreated","name":"SessionCreated","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionCreated returns materialized \"session-created\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.SessionCreated","product":"core","slug":"tmux-sessionhookvalues-sessioncreated"},{"id":"tmux.SessionHookValues.SessionRenamed","name":"SessionRenamed","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionRenamed returns materialized \"session-renamed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4116,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.SessionRenamed","product":"core","slug":"tmux-sessionhookvalues-sessionrenamed"},{"id":"tmux.SessionHookValues.SessionWindowChanged","name":"SessionWindowChanged","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"SessionWindowChanged returns materialized \"session-window-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4121,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.SessionWindowChanged","product":"core","slug":"tmux-sessionhookvalues-sessionwindowchanged"},{"id":"tmux.SessionHookValues.WindowLinked","name":"WindowLinked","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowLinked returns materialized \"window-linked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4128,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.WindowLinked","product":"core","slug":"tmux-sessionhookvalues-windowlinked"},{"id":"tmux.SessionHookValues.WindowUnlinked","name":"WindowUnlinked","kind":"method","modifiers":[],"parent":"tmux.SessionHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowUnlinked returns materialized \"window-unlinked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from session hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4133,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionHookValues.WindowUnlinked","product":"core","slug":"tmux-sessionhookvalues-windowunlinked"},{"id":"tmux.WindowHookValues","name":"WindowHookValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowHookValues is an immutable materialized view of known window hook values; its zero value is empty and it does not refresh. Obtain it with [Window.Hooks] or [GlobalWindowScope.Hooks]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Window.RawHook] or [GlobalWindowScope.RawHook] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":4261,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues","product":"core","slug":"tmux-windowhookvalues"},{"id":"tmux.WindowHookValues.PaneDied","name":"PaneDied","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneDied returns materialized \"pane-died\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4280,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.PaneDied","product":"core","slug":"tmux-windowhookvalues-panedied"},{"id":"tmux.WindowHookValues.PaneExited","name":"PaneExited","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneExited returns materialized \"pane-exited\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4285,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.PaneExited","product":"core","slug":"tmux-windowhookvalues-paneexited"},{"id":"tmux.WindowHookValues.PaneFocusIn","name":"PaneFocusIn","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneFocusIn returns materialized \"pane-focus-in\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4290,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.PaneFocusIn","product":"core","slug":"tmux-windowhookvalues-panefocusin"},{"id":"tmux.WindowHookValues.PaneFocusOut","name":"PaneFocusOut","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneFocusOut returns materialized \"pane-focus-out\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4295,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.PaneFocusOut","product":"core","slug":"tmux-windowhookvalues-panefocusout"},{"id":"tmux.WindowHookValues.PaneModeChanged","name":"PaneModeChanged","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneModeChanged returns materialized \"pane-mode-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4300,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.PaneModeChanged","product":"core","slug":"tmux-windowhookvalues-panemodechanged"},{"id":"tmux.WindowHookValues.PaneSetClipboard","name":"PaneSetClipboard","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneSetClipboard returns materialized \"pane-set-clipboard\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4307,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.PaneSetClipboard","product":"core","slug":"tmux-windowhookvalues-panesetclipboard"},{"id":"tmux.WindowHookValues.PaneTitleChanged","name":"PaneTitleChanged","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneTitleChanged returns materialized \"pane-title-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4314,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.PaneTitleChanged","product":"core","slug":"tmux-windowhookvalues-panetitlechanged"},{"id":"tmux.WindowHookValues.WindowLayoutChanged","name":"WindowLayoutChanged","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowLayoutChanged returns materialized \"window-layout-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4321,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.WindowLayoutChanged","product":"core","slug":"tmux-windowhookvalues-windowlayoutchanged"},{"id":"tmux.WindowHookValues.WindowLinked","name":"WindowLinked","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowLinked returns materialized \"window-linked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4328,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.WindowLinked","product":"core","slug":"tmux-windowhookvalues-windowlinked"},{"id":"tmux.WindowHookValues.WindowPaneChanged","name":"WindowPaneChanged","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowPaneChanged returns materialized \"window-pane-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4333,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.WindowPaneChanged","product":"core","slug":"tmux-windowhookvalues-windowpanechanged"},{"id":"tmux.WindowHookValues.WindowRenamed","name":"WindowRenamed","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowRenamed returns materialized \"window-renamed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4340,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.WindowRenamed","product":"core","slug":"tmux-windowhookvalues-windowrenamed"},{"id":"tmux.WindowHookValues.WindowResized","name":"WindowResized","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowResized returns materialized \"window-resized\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.3. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4345,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.WindowResized","product":"core","slug":"tmux-windowhookvalues-windowresized"},{"id":"tmux.WindowHookValues.WindowUnlinked","name":"WindowUnlinked","kind":"method","modifiers":[],"parent":"tmux.WindowHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"WindowUnlinked returns materialized \"window-unlinked\" as [OptionValue] with value type OptionValue[SparseArray[string]] from window hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4350,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowHookValues.WindowUnlinked","product":"core","slug":"tmux-windowhookvalues-windowunlinked"},{"id":"tmux.PaneHookValues","name":"PaneHookValues","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneHookValues is an immutable materialized view of known pane hook values; its zero value is empty and it does not refresh. Obtain it with [Pane.Hooks]. [OptionValue.Get] reports presence and [OptionValue.Origin] reports inheritance. Use [Pane.RawHook] for caller-named or undecoded values."},"source":{"file":"tmux/option_generated.go","line":4390,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneHookValues","product":"core","slug":"tmux-panehookvalues"},{"id":"tmux.PaneHookValues.PaneDied","name":"PaneDied","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneDied returns materialized \"pane-died\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4403,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneHookValues.PaneDied","product":"core","slug":"tmux-panehookvalues-panedied"},{"id":"tmux.PaneHookValues.PaneExited","name":"PaneExited","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneExited returns materialized \"pane-exited\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4408,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneHookValues.PaneExited","product":"core","slug":"tmux-panehookvalues-paneexited"},{"id":"tmux.PaneHookValues.PaneFocusIn","name":"PaneFocusIn","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneFocusIn returns materialized \"pane-focus-in\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4413,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneHookValues.PaneFocusIn","product":"core","slug":"tmux-panehookvalues-panefocusin"},{"id":"tmux.PaneHookValues.PaneFocusOut","name":"PaneFocusOut","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneFocusOut returns materialized \"pane-focus-out\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4418,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneHookValues.PaneFocusOut","product":"core","slug":"tmux-panehookvalues-panefocusout"},{"id":"tmux.PaneHookValues.PaneModeChanged","name":"PaneModeChanged","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneModeChanged returns materialized \"pane-mode-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4423,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneHookValues.PaneModeChanged","product":"core","slug":"tmux-panehookvalues-panemodechanged"},{"id":"tmux.PaneHookValues.PaneSetClipboard","name":"PaneSetClipboard","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneSetClipboard returns materialized \"pane-set-clipboard\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4428,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneHookValues.PaneSetClipboard","product":"core","slug":"tmux-panehookvalues-panesetclipboard"},{"id":"tmux.PaneHookValues.PaneTitleChanged","name":"PaneTitleChanged","kind":"method","modifiers":[],"parent":"tmux.PaneHookValues","signatures":[{"params":[],"returns":"OptionValue[SparseArray[string]]"}],"doc":{"summary":"PaneTitleChanged returns materialized \"pane-title-changed\" as [OptionValue] with value type OptionValue[SparseArray[string]] from pane hook values; it does not query tmux. Available as COMMAND since tmux 3.2a. Its present SparseArray value preserves assigned tmux indexes, including gaps."},"source":{"file":"tmux/option_generated.go","line":4435,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneHookValues.PaneTitleChanged","product":"core","slug":"tmux-panehookvalues-panetitlechanged"},{"id":"tmux.Session.SetActivityAction","name":"SetActivityAction","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ActivityAction"}],"returns":"error"}],"doc":{"summary":"SetActivityAction stores the \"activity-action\" session option as ActivityAction (tmux 3.2a or later). Read it with [SessionOptionValues.ActivityAction] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4464,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetActivityAction","product":"core","slug":"tmux-session-setactivityaction"},{"id":"tmux.GlobalSessionScope.SetActivityAction","name":"SetActivityAction","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ActivityAction"}],"returns":"error"}],"doc":{"summary":"SetActivityAction stores the \"activity-action\" session option as ActivityAction (tmux 3.2a or later). Read it with [SessionOptionValues.ActivityAction] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4474,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetActivityAction","product":"core","slug":"tmux-globalsessionscope-setactivityaction"},{"id":"tmux.Window.SetAggressiveResize","name":"SetAggressiveResize","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAggressiveResize stores the \"aggressive-resize\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AggressiveResize] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4482,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetAggressiveResize","product":"core","slug":"tmux-window-setaggressiveresize"},{"id":"tmux.GlobalWindowScope.SetAggressiveResize","name":"SetAggressiveResize","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAggressiveResize stores the \"aggressive-resize\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AggressiveResize] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4492,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetAggressiveResize","product":"core","slug":"tmux-globalwindowscope-setaggressiveresize"},{"id":"tmux.Window.SetAllowPassthrough","name":"SetAllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"AllowPassthrough"}],"returns":"error"}],"doc":{"summary":"SetAllowPassthrough stores the \"allow-passthrough\" window option as AllowPassthrough (tmux 3.3 or later). Read it with [WindowOptionValues.AllowPassthrough] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4500,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetAllowPassthrough","product":"core","slug":"tmux-window-setallowpassthrough"},{"id":"tmux.GlobalWindowScope.SetAllowPassthrough","name":"SetAllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"AllowPassthrough"}],"returns":"error"}],"doc":{"summary":"SetAllowPassthrough stores the \"allow-passthrough\" window option as AllowPassthrough (tmux 3.3 or later). Read it with [WindowOptionValues.AllowPassthrough] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4510,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetAllowPassthrough","product":"core","slug":"tmux-globalwindowscope-setallowpassthrough"},{"id":"tmux.Pane.SetAllowPassthrough","name":"SetAllowPassthrough","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"AllowPassthrough"}],"returns":"error"}],"doc":{"summary":"SetAllowPassthrough stores the \"allow-passthrough\" pane option as AllowPassthrough (tmux 3.3 or later). Read it with [PaneOptionValues.AllowPassthrough] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4518,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetAllowPassthrough","product":"core","slug":"tmux-pane-setallowpassthrough"},{"id":"tmux.Window.SetAllowRename","name":"SetAllowRename","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowRename stores the \"allow-rename\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AllowRename] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4528,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetAllowRename","product":"core","slug":"tmux-window-setallowrename"},{"id":"tmux.GlobalWindowScope.SetAllowRename","name":"SetAllowRename","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowRename stores the \"allow-rename\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AllowRename] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4538,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetAllowRename","product":"core","slug":"tmux-globalwindowscope-setallowrename"},{"id":"tmux.Pane.SetAllowRename","name":"SetAllowRename","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowRename stores the \"allow-rename\" pane option as bool (tmux 3.2a or later). Read it with [PaneOptionValues.AllowRename] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4546,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetAllowRename","product":"core","slug":"tmux-pane-setallowrename"},{"id":"tmux.Window.SetAllowSetTitle","name":"SetAllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowSetTitle stores the \"allow-set-title\" window option as bool (tmux 3.5 or later). Read it with [WindowOptionValues.AllowSetTitle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4556,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetAllowSetTitle","product":"core","slug":"tmux-window-setallowsettitle"},{"id":"tmux.GlobalWindowScope.SetAllowSetTitle","name":"SetAllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowSetTitle stores the \"allow-set-title\" window option as bool (tmux 3.5 or later). Read it with [WindowOptionValues.AllowSetTitle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4566,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetAllowSetTitle","product":"core","slug":"tmux-globalwindowscope-setallowsettitle"},{"id":"tmux.Pane.SetAllowSetTitle","name":"SetAllowSetTitle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAllowSetTitle stores the \"allow-set-title\" pane option as bool (tmux 3.5 or later). Read it with [PaneOptionValues.AllowSetTitle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4574,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetAllowSetTitle","product":"core","slug":"tmux-pane-setallowsettitle"},{"id":"tmux.Window.SetAlternateScreen","name":"SetAlternateScreen","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAlternateScreen stores the \"alternate-screen\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AlternateScreen] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4584,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetAlternateScreen","product":"core","slug":"tmux-window-setalternatescreen"},{"id":"tmux.GlobalWindowScope.SetAlternateScreen","name":"SetAlternateScreen","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAlternateScreen stores the \"alternate-screen\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AlternateScreen] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4594,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetAlternateScreen","product":"core","slug":"tmux-globalwindowscope-setalternatescreen"},{"id":"tmux.Pane.SetAlternateScreen","name":"SetAlternateScreen","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAlternateScreen stores the \"alternate-screen\" pane option as bool (tmux 3.2a or later). Read it with [PaneOptionValues.AlternateScreen] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4602,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetAlternateScreen","product":"core","slug":"tmux-pane-setalternatescreen"},{"id":"tmux.Session.SetAssumePasteTime","name":"SetAssumePasteTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetAssumePasteTime stores the \"assume-paste-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.AssumePasteTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4612,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetAssumePasteTime","product":"core","slug":"tmux-session-setassumepastetime"},{"id":"tmux.GlobalSessionScope.SetAssumePasteTime","name":"SetAssumePasteTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetAssumePasteTime stores the \"assume-paste-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.AssumePasteTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4626,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetAssumePasteTime","product":"core","slug":"tmux-globalsessionscope-setassumepastetime"},{"id":"tmux.Window.SetAutomaticRename","name":"SetAutomaticRename","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAutomaticRename stores the \"automatic-rename\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AutomaticRename] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4638,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetAutomaticRename","product":"core","slug":"tmux-window-setautomaticrename"},{"id":"tmux.GlobalWindowScope.SetAutomaticRename","name":"SetAutomaticRename","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetAutomaticRename stores the \"automatic-rename\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.AutomaticRename] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4648,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetAutomaticRename","product":"core","slug":"tmux-globalwindowscope-setautomaticrename"},{"id":"tmux.Window.SetAutomaticRenameFormat","name":"SetAutomaticRenameFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetAutomaticRenameFormat stores the \"automatic-rename-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.AutomaticRenameFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4656,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetAutomaticRenameFormat","product":"core","slug":"tmux-window-setautomaticrenameformat"},{"id":"tmux.GlobalWindowScope.SetAutomaticRenameFormat","name":"SetAutomaticRenameFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetAutomaticRenameFormat stores the \"automatic-rename-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.AutomaticRenameFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4666,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetAutomaticRenameFormat","product":"core","slug":"tmux-globalwindowscope-setautomaticrenameformat"},{"id":"tmux.Server.SetBackspace","name":"SetBackspace","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetBackspace stores the \"backspace\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.Backspace] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4674,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetBackspace","product":"core","slug":"tmux-server-setbackspace"},{"id":"tmux.Session.SetBaseIndex","name":"SetBaseIndex","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetBaseIndex stores the \"base-index\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.BaseIndex] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4682,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetBaseIndex","product":"core","slug":"tmux-session-setbaseindex"},{"id":"tmux.GlobalSessionScope.SetBaseIndex","name":"SetBaseIndex","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetBaseIndex stores the \"base-index\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.BaseIndex] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4692,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetBaseIndex","product":"core","slug":"tmux-globalsessionscope-setbaseindex"},{"id":"tmux.Session.SetBellAction","name":"SetBellAction","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"BellAction"}],"returns":"error"}],"doc":{"summary":"SetBellAction stores the \"bell-action\" session option as BellAction (tmux 3.2a or later). Read it with [SessionOptionValues.BellAction] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4700,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetBellAction","product":"core","slug":"tmux-session-setbellaction"},{"id":"tmux.GlobalSessionScope.SetBellAction","name":"SetBellAction","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"BellAction"}],"returns":"error"}],"doc":{"summary":"SetBellAction stores the \"bell-action\" session option as BellAction (tmux 3.2a or later). Read it with [SessionOptionValues.BellAction] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4710,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetBellAction","product":"core","slug":"tmux-globalsessionscope-setbellaction"},{"id":"tmux.Server.SetBufferLimit","name":"SetBufferLimit","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetBufferLimit stores the \"buffer-limit\" server option as int64 (tmux 3.2a or later). Read it with [ServerOptionValues.BufferLimit] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4718,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetBufferLimit","product":"core","slug":"tmux-server-setbufferlimit"},{"id":"tmux.Window.SetClockModeColour","name":"SetClockModeColour","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetClockModeColour stores the \"clock-mode-colour\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.ClockModeColour] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4726,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetClockModeColour","product":"core","slug":"tmux-window-setclockmodecolour"},{"id":"tmux.GlobalWindowScope.SetClockModeColour","name":"SetClockModeColour","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetClockModeColour stores the \"clock-mode-colour\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.ClockModeColour] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4736,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetClockModeColour","product":"core","slug":"tmux-globalwindowscope-setclockmodecolour"},{"id":"tmux.Window.SetClockModeStyle","name":"SetClockModeStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ClockModeStyle"}],"returns":"error"}],"doc":{"summary":"SetClockModeStyle stores the \"clock-mode-style\" window option as ClockModeStyle (tmux 3.2a or later). Read it with [WindowOptionValues.ClockModeStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4744,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetClockModeStyle","product":"core","slug":"tmux-window-setclockmodestyle"},{"id":"tmux.GlobalWindowScope.SetClockModeStyle","name":"SetClockModeStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ClockModeStyle"}],"returns":"error"}],"doc":{"summary":"SetClockModeStyle stores the \"clock-mode-style\" window option as ClockModeStyle (tmux 3.2a or later). Read it with [WindowOptionValues.ClockModeStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4754,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetClockModeStyle","product":"core","slug":"tmux-globalwindowscope-setclockmodestyle"},{"id":"tmux.Server.SetCopyCommand","name":"SetCopyCommand","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyCommand stores the \"copy-command\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.CopyCommand] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4762,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetCopyCommand","product":"core","slug":"tmux-server-setcopycommand"},{"id":"tmux.Window.SetCopyModeCurrentLineNumberStyle","name":"SetCopyModeCurrentLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeCurrentLineNumberStyle stores the \"copy-mode-current-line-number-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeCurrentLineNumberStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4770,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModeCurrentLineNumberStyle","product":"core","slug":"tmux-window-setcopymodecurrentlinenumberstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeCurrentLineNumberStyle","name":"SetCopyModeCurrentLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeCurrentLineNumberStyle stores the \"copy-mode-current-line-number-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeCurrentLineNumberStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4780,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModeCurrentLineNumberStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodecurrentlinenumberstyle"},{"id":"tmux.Window.SetCopyModeCurrentMatchStyle","name":"SetCopyModeCurrentMatchStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeCurrentMatchStyle stores the \"copy-mode-current-match-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeCurrentMatchStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4788,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModeCurrentMatchStyle","product":"core","slug":"tmux-window-setcopymodecurrentmatchstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeCurrentMatchStyle","name":"SetCopyModeCurrentMatchStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeCurrentMatchStyle stores the \"copy-mode-current-match-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeCurrentMatchStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4798,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModeCurrentMatchStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodecurrentmatchstyle"},{"id":"tmux.Window.SetCopyModeLineNumberStyle","name":"SetCopyModeLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeLineNumberStyle stores the \"copy-mode-line-number-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeLineNumberStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4806,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModeLineNumberStyle","product":"core","slug":"tmux-window-setcopymodelinenumberstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeLineNumberStyle","name":"SetCopyModeLineNumberStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeLineNumberStyle stores the \"copy-mode-line-number-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeLineNumberStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4816,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModeLineNumberStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodelinenumberstyle"},{"id":"tmux.Window.SetCopyModeLineNumbers","name":"SetCopyModeLineNumbers","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CopyModeLineNumbers"}],"returns":"error"}],"doc":{"summary":"SetCopyModeLineNumbers stores the \"copy-mode-line-numbers\" window option as CopyModeLineNumbers (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeLineNumbers] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4824,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModeLineNumbers","product":"core","slug":"tmux-window-setcopymodelinenumbers"},{"id":"tmux.GlobalWindowScope.SetCopyModeLineNumbers","name":"SetCopyModeLineNumbers","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CopyModeLineNumbers"}],"returns":"error"}],"doc":{"summary":"SetCopyModeLineNumbers stores the \"copy-mode-line-numbers\" window option as CopyModeLineNumbers (tmux 3.7 or later). Read it with [WindowOptionValues.CopyModeLineNumbers] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4834,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModeLineNumbers","product":"core","slug":"tmux-globalwindowscope-setcopymodelinenumbers"},{"id":"tmux.Window.SetCopyModeMarkStyle","name":"SetCopyModeMarkStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeMarkStyle stores the \"copy-mode-mark-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeMarkStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4842,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModeMarkStyle","product":"core","slug":"tmux-window-setcopymodemarkstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeMarkStyle","name":"SetCopyModeMarkStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeMarkStyle stores the \"copy-mode-mark-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeMarkStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4852,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModeMarkStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodemarkstyle"},{"id":"tmux.Window.SetCopyModeMatchStyle","name":"SetCopyModeMatchStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeMatchStyle stores the \"copy-mode-match-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeMatchStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4860,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModeMatchStyle","product":"core","slug":"tmux-window-setcopymodematchstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeMatchStyle","name":"SetCopyModeMatchStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeMatchStyle stores the \"copy-mode-match-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.CopyModeMatchStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4870,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModeMatchStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodematchstyle"},{"id":"tmux.Window.SetCopyModePositionFormat","name":"SetCopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionFormat stores the \"copy-mode-position-format\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModePositionFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4878,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModePositionFormat","product":"core","slug":"tmux-window-setcopymodepositionformat"},{"id":"tmux.GlobalWindowScope.SetCopyModePositionFormat","name":"SetCopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionFormat stores the \"copy-mode-position-format\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModePositionFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4888,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModePositionFormat","product":"core","slug":"tmux-globalwindowscope-setcopymodepositionformat"},{"id":"tmux.Pane.SetCopyModePositionFormat","name":"SetCopyModePositionFormat","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionFormat stores the \"copy-mode-position-format\" pane option as string (tmux 3.6 or later). Read it with [PaneOptionValues.CopyModePositionFormat] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4896,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetCopyModePositionFormat","product":"core","slug":"tmux-pane-setcopymodepositionformat"},{"id":"tmux.Window.SetCopyModePositionStyle","name":"SetCopyModePositionStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionStyle stores the \"copy-mode-position-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModePositionStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4906,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModePositionStyle","product":"core","slug":"tmux-window-setcopymodepositionstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModePositionStyle","name":"SetCopyModePositionStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModePositionStyle stores the \"copy-mode-position-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModePositionStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4916,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModePositionStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodepositionstyle"},{"id":"tmux.Window.SetCopyModeSelectionStyle","name":"SetCopyModeSelectionStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeSelectionStyle stores the \"copy-mode-selection-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModeSelectionStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4924,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCopyModeSelectionStyle","product":"core","slug":"tmux-window-setcopymodeselectionstyle"},{"id":"tmux.GlobalWindowScope.SetCopyModeSelectionStyle","name":"SetCopyModeSelectionStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCopyModeSelectionStyle stores the \"copy-mode-selection-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.CopyModeSelectionStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4934,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCopyModeSelectionStyle","product":"core","slug":"tmux-globalwindowscope-setcopymodeselectionstyle"},{"id":"tmux.Window.SetCursorColour","name":"SetCursorColour","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCursorColour stores the \"cursor-colour\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.CursorColour] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4942,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCursorColour","product":"core","slug":"tmux-window-setcursorcolour"},{"id":"tmux.GlobalWindowScope.SetCursorColour","name":"SetCursorColour","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCursorColour stores the \"cursor-colour\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.CursorColour] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4952,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCursorColour","product":"core","slug":"tmux-globalwindowscope-setcursorcolour"},{"id":"tmux.Pane.SetCursorColour","name":"SetCursorColour","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetCursorColour stores the \"cursor-colour\" pane option as string (tmux 3.3 or later). Read it with [PaneOptionValues.CursorColour] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4960,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetCursorColour","product":"core","slug":"tmux-pane-setcursorcolour"},{"id":"tmux.Window.SetCursorStyle","name":"SetCursorStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CursorStyle"}],"returns":"error"}],"doc":{"summary":"SetCursorStyle stores the \"cursor-style\" window option as CursorStyle (tmux 3.3 or later). Read it with [WindowOptionValues.CursorStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4970,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetCursorStyle","product":"core","slug":"tmux-window-setcursorstyle"},{"id":"tmux.GlobalWindowScope.SetCursorStyle","name":"SetCursorStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CursorStyle"}],"returns":"error"}],"doc":{"summary":"SetCursorStyle stores the \"cursor-style\" window option as CursorStyle (tmux 3.3 or later). Read it with [WindowOptionValues.CursorStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4980,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetCursorStyle","product":"core","slug":"tmux-globalwindowscope-setcursorstyle"},{"id":"tmux.Pane.SetCursorStyle","name":"SetCursorStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"CursorStyle"}],"returns":"error"}],"doc":{"summary":"SetCursorStyle stores the \"cursor-style\" pane option as CursorStyle (tmux 3.3 or later). Read it with [PaneOptionValues.CursorStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4988,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetCursorStyle","product":"core","slug":"tmux-pane-setcursorstyle"},{"id":"tmux.Server.SetDefaultClientCommand","name":"SetDefaultClientCommand","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultClientCommand stores the \"default-client-command\" server option as string (tmux 3.6 or later). Read it with [ServerOptionValues.DefaultClientCommand] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":4998,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetDefaultClientCommand","product":"core","slug":"tmux-server-setdefaultclientcommand"},{"id":"tmux.Session.SetDefaultCommand","name":"SetDefaultCommand","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultCommand stores the \"default-command\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultCommand] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5006,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDefaultCommand","product":"core","slug":"tmux-session-setdefaultcommand"},{"id":"tmux.GlobalSessionScope.SetDefaultCommand","name":"SetDefaultCommand","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultCommand stores the \"default-command\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultCommand] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5016,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDefaultCommand","product":"core","slug":"tmux-globalsessionscope-setdefaultcommand"},{"id":"tmux.Session.SetDefaultShell","name":"SetDefaultShell","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultShell stores the \"default-shell\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultShell] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5024,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDefaultShell","product":"core","slug":"tmux-session-setdefaultshell"},{"id":"tmux.GlobalSessionScope.SetDefaultShell","name":"SetDefaultShell","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultShell stores the \"default-shell\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultShell] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5034,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDefaultShell","product":"core","slug":"tmux-globalsessionscope-setdefaultshell"},{"id":"tmux.Session.SetDefaultSize","name":"SetDefaultSize","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultSize stores the \"default-size\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultSize] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5042,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDefaultSize","product":"core","slug":"tmux-session-setdefaultsize"},{"id":"tmux.GlobalSessionScope.SetDefaultSize","name":"SetDefaultSize","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultSize stores the \"default-size\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DefaultSize] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5052,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDefaultSize","product":"core","slug":"tmux-globalsessionscope-setdefaultsize"},{"id":"tmux.Server.SetDefaultTerminal","name":"SetDefaultTerminal","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDefaultTerminal stores the \"default-terminal\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.DefaultTerminal] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5060,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetDefaultTerminal","product":"core","slug":"tmux-server-setdefaultterminal"},{"id":"tmux.Session.SetDestroyUnattached","name":"SetDestroyUnattached","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"DestroyUnattached"}],"returns":"error"}],"doc":{"summary":"SetDestroyUnattached stores the \"destroy-unattached\" session option as DestroyUnattached (tmux 3.2a or later). Read it with [SessionOptionValues.DestroyUnattached] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5068,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDestroyUnattached","product":"core","slug":"tmux-session-setdestroyunattached"},{"id":"tmux.GlobalSessionScope.SetDestroyUnattached","name":"SetDestroyUnattached","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"DestroyUnattached"}],"returns":"error"}],"doc":{"summary":"SetDestroyUnattached stores the \"destroy-unattached\" session option as DestroyUnattached (tmux 3.2a or later). Read it with [SessionOptionValues.DestroyUnattached] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5078,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDestroyUnattached","product":"core","slug":"tmux-globalsessionscope-setdestroyunattached"},{"id":"tmux.Session.SetDetachOnDestroy","name":"SetDetachOnDestroy","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"DetachOnDestroy"}],"returns":"error"}],"doc":{"summary":"SetDetachOnDestroy stores the \"detach-on-destroy\" session option as DetachOnDestroy (tmux 3.2a or later). Read it with [SessionOptionValues.DetachOnDestroy] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5086,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDetachOnDestroy","product":"core","slug":"tmux-session-setdetachondestroy"},{"id":"tmux.GlobalSessionScope.SetDetachOnDestroy","name":"SetDetachOnDestroy","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"DetachOnDestroy"}],"returns":"error"}],"doc":{"summary":"SetDetachOnDestroy stores the \"detach-on-destroy\" session option as DetachOnDestroy (tmux 3.2a or later). Read it with [SessionOptionValues.DetachOnDestroy] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5096,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDetachOnDestroy","product":"core","slug":"tmux-globalsessionscope-setdetachondestroy"},{"id":"tmux.Session.SetDisplayPanesActiveColour","name":"SetDisplayPanesActiveColour","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesActiveColour stores the \"display-panes-active-colour\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesActiveColour] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDisplayPanesActiveColour","product":"core","slug":"tmux-session-setdisplaypanesactivecolour"},{"id":"tmux.GlobalSessionScope.SetDisplayPanesActiveColour","name":"SetDisplayPanesActiveColour","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesActiveColour stores the \"display-panes-active-colour\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesActiveColour] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5114,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDisplayPanesActiveColour","product":"core","slug":"tmux-globalsessionscope-setdisplaypanesactivecolour"},{"id":"tmux.Session.SetDisplayPanesColour","name":"SetDisplayPanesColour","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesColour stores the \"display-panes-colour\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesColour] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5122,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDisplayPanesColour","product":"core","slug":"tmux-session-setdisplaypanescolour"},{"id":"tmux.GlobalSessionScope.SetDisplayPanesColour","name":"SetDisplayPanesColour","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesColour stores the \"display-panes-colour\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesColour] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5132,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDisplayPanesColour","product":"core","slug":"tmux-globalsessionscope-setdisplaypanescolour"},{"id":"tmux.Session.SetDisplayPanesTime","name":"SetDisplayPanesTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesTime stores the \"display-panes-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5140,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDisplayPanesTime","product":"core","slug":"tmux-session-setdisplaypanestime"},{"id":"tmux.GlobalSessionScope.SetDisplayPanesTime","name":"SetDisplayPanesTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetDisplayPanesTime stores the \"display-panes-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayPanesTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5154,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDisplayPanesTime","product":"core","slug":"tmux-globalsessionscope-setdisplaypanestime"},{"id":"tmux.Session.SetDisplayTime","name":"SetDisplayTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetDisplayTime stores the \"display-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5166,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetDisplayTime","product":"core","slug":"tmux-session-setdisplaytime"},{"id":"tmux.GlobalSessionScope.SetDisplayTime","name":"SetDisplayTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetDisplayTime stores the \"display-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.DisplayTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5180,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetDisplayTime","product":"core","slug":"tmux-globalsessionscope-setdisplaytime"},{"id":"tmux.Server.SetEditor","name":"SetEditor","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetEditor stores the \"editor\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.Editor] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5192,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetEditor","product":"core","slug":"tmux-server-seteditor"},{"id":"tmux.Server.SetEscapeTime","name":"SetEscapeTime","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetEscapeTime stores the \"escape-time\" server option as time.Duration (tmux 3.2a or later). Read it with [ServerOptionValues.EscapeTime] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5200,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetEscapeTime","product":"core","slug":"tmux-server-setescapetime"},{"id":"tmux.Server.SetExitEmpty","name":"SetExitEmpty","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetExitEmpty stores the \"exit-empty\" server option as bool (tmux 3.2a or later). Read it with [ServerOptionValues.ExitEmpty] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5212,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetExitEmpty","product":"core","slug":"tmux-server-setexitempty"},{"id":"tmux.Server.SetExitUnattached","name":"SetExitUnattached","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetExitUnattached stores the \"exit-unattached\" server option as bool (tmux 3.2a or later). Read it with [ServerOptionValues.ExitUnattached] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5220,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetExitUnattached","product":"core","slug":"tmux-server-setexitunattached"},{"id":"tmux.Server.SetExtendedKeys","name":"SetExtendedKeys","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ExtendedKeys"}],"returns":"error"}],"doc":{"summary":"SetExtendedKeys stores the \"extended-keys\" server option as ExtendedKeys (tmux 3.2a or later). Read it with [ServerOptionValues.ExtendedKeys] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5228,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetExtendedKeys","product":"core","slug":"tmux-server-setextendedkeys"},{"id":"tmux.Server.SetExtendedKeysFormat","name":"SetExtendedKeysFormat","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ExtendedKeysFormat"}],"returns":"error"}],"doc":{"summary":"SetExtendedKeysFormat stores the \"extended-keys-format\" server option as ExtendedKeysFormat (tmux 3.5 or later). Read it with [ServerOptionValues.ExtendedKeysFormat] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5236,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetExtendedKeysFormat","product":"core","slug":"tmux-server-setextendedkeysformat"},{"id":"tmux.Window.SetFillCharacter","name":"SetFillCharacter","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetFillCharacter stores the \"fill-character\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.FillCharacter] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5244,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetFillCharacter","product":"core","slug":"tmux-window-setfillcharacter"},{"id":"tmux.GlobalWindowScope.SetFillCharacter","name":"SetFillCharacter","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetFillCharacter stores the \"fill-character\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.FillCharacter] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5254,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetFillCharacter","product":"core","slug":"tmux-globalwindowscope-setfillcharacter"},{"id":"tmux.Server.SetFocusEvents","name":"SetFocusEvents","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetFocusEvents stores the \"focus-events\" server option as bool (tmux 3.2a or later). Read it with [ServerOptionValues.FocusEvents] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5262,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetFocusEvents","product":"core","slug":"tmux-server-setfocusevents"},{"id":"tmux.Session.SetFocusFollowsMouse","name":"SetFocusFollowsMouse","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetFocusFollowsMouse stores the \"focus-follows-mouse\" session option as bool (tmux 3.7 or later). Read it with [SessionOptionValues.FocusFollowsMouse] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5270,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetFocusFollowsMouse","product":"core","slug":"tmux-session-setfocusfollowsmouse"},{"id":"tmux.GlobalSessionScope.SetFocusFollowsMouse","name":"SetFocusFollowsMouse","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetFocusFollowsMouse stores the \"focus-follows-mouse\" session option as bool (tmux 3.7 or later). Read it with [SessionOptionValues.FocusFollowsMouse] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5280,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetFocusFollowsMouse","product":"core","slug":"tmux-globalsessionscope-setfocusfollowsmouse"},{"id":"tmux.Server.SetGetClipboard","name":"SetGetClipboard","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"GetClipboard"}],"returns":"error"}],"doc":{"summary":"SetGetClipboard stores the \"get-clipboard\" server option as GetClipboard (tmux 3.7 or later). Read it with [ServerOptionValues.GetClipboard] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5288,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetGetClipboard","product":"core","slug":"tmux-server-setgetclipboard"},{"id":"tmux.Server.SetHistoryFile","name":"SetHistoryFile","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetHistoryFile stores the \"history-file\" server option as string (tmux 3.2a or later). Read it with [ServerOptionValues.HistoryFile] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5296,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetHistoryFile","product":"core","slug":"tmux-server-sethistoryfile"},{"id":"tmux.Session.SetHistoryLimit","name":"SetHistoryLimit","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetHistoryLimit stores the \"history-limit\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.HistoryLimit] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5304,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetHistoryLimit","product":"core","slug":"tmux-session-sethistorylimit"},{"id":"tmux.GlobalSessionScope.SetHistoryLimit","name":"SetHistoryLimit","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetHistoryLimit stores the \"history-limit\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.HistoryLimit] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5314,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetHistoryLimit","product":"core","slug":"tmux-globalsessionscope-sethistorylimit"},{"id":"tmux.Session.SetInitialRepeatTime","name":"SetInitialRepeatTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetInitialRepeatTime stores the \"initial-repeat-time\" session option as time.Duration (tmux 3.6 or later). Read it with [SessionOptionValues.InitialRepeatTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5322,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetInitialRepeatTime","product":"core","slug":"tmux-session-setinitialrepeattime"},{"id":"tmux.GlobalSessionScope.SetInitialRepeatTime","name":"SetInitialRepeatTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetInitialRepeatTime stores the \"initial-repeat-time\" session option as time.Duration (tmux 3.6 or later). Read it with [SessionOptionValues.InitialRepeatTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5336,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetInitialRepeatTime","product":"core","slug":"tmux-globalsessionscope-setinitialrepeattime"},{"id":"tmux.Server.SetInputBufferSize","name":"SetInputBufferSize","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetInputBufferSize stores the \"input-buffer-size\" server option as int64 (tmux 3.6 or later). Read it with [ServerOptionValues.InputBufferSize] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5348,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetInputBufferSize","product":"core","slug":"tmux-server-setinputbuffersize"},{"id":"tmux.Session.SetKeyTable","name":"SetKeyTable","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetKeyTable stores the \"key-table\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.KeyTable] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5356,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetKeyTable","product":"core","slug":"tmux-session-setkeytable"},{"id":"tmux.GlobalSessionScope.SetKeyTable","name":"SetKeyTable","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetKeyTable stores the \"key-table\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.KeyTable] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5366,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetKeyTable","product":"core","slug":"tmux-globalsessionscope-setkeytable"},{"id":"tmux.Session.SetLockAfterTime","name":"SetLockAfterTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetLockAfterTime stores the \"lock-after-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.LockAfterTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5374,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetLockAfterTime","product":"core","slug":"tmux-session-setlockaftertime"},{"id":"tmux.GlobalSessionScope.SetLockAfterTime","name":"SetLockAfterTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetLockAfterTime stores the \"lock-after-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.LockAfterTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5388,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetLockAfterTime","product":"core","slug":"tmux-globalsessionscope-setlockaftertime"},{"id":"tmux.Session.SetLockCommand","name":"SetLockCommand","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetLockCommand stores the \"lock-command\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.LockCommand] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5400,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetLockCommand","product":"core","slug":"tmux-session-setlockcommand"},{"id":"tmux.GlobalSessionScope.SetLockCommand","name":"SetLockCommand","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetLockCommand stores the \"lock-command\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.LockCommand] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5410,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetLockCommand","product":"core","slug":"tmux-globalsessionscope-setlockcommand"},{"id":"tmux.Window.SetMainPaneHeight","name":"SetMainPaneHeight","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMainPaneHeight stores the \"main-pane-height\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.MainPaneHeight] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5418,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMainPaneHeight","product":"core","slug":"tmux-window-setmainpaneheight"},{"id":"tmux.GlobalWindowScope.SetMainPaneHeight","name":"SetMainPaneHeight","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMainPaneHeight stores the \"main-pane-height\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.MainPaneHeight] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5428,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMainPaneHeight","product":"core","slug":"tmux-globalwindowscope-setmainpaneheight"},{"id":"tmux.Window.SetMainPaneWidth","name":"SetMainPaneWidth","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMainPaneWidth stores the \"main-pane-width\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.MainPaneWidth] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5436,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMainPaneWidth","product":"core","slug":"tmux-window-setmainpanewidth"},{"id":"tmux.GlobalWindowScope.SetMainPaneWidth","name":"SetMainPaneWidth","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMainPaneWidth stores the \"main-pane-width\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.MainPaneWidth] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5446,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMainPaneWidth","product":"core","slug":"tmux-globalwindowscope-setmainpanewidth"},{"id":"tmux.Window.SetMenuBorderLines","name":"SetMenuBorderLines","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"MenuBorderLines"}],"returns":"error"}],"doc":{"summary":"SetMenuBorderLines stores the \"menu-border-lines\" window option as MenuBorderLines (tmux 3.4 or later). Read it with [WindowOptionValues.MenuBorderLines] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5454,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMenuBorderLines","product":"core","slug":"tmux-window-setmenuborderlines"},{"id":"tmux.GlobalWindowScope.SetMenuBorderLines","name":"SetMenuBorderLines","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"MenuBorderLines"}],"returns":"error"}],"doc":{"summary":"SetMenuBorderLines stores the \"menu-border-lines\" window option as MenuBorderLines (tmux 3.4 or later). Read it with [WindowOptionValues.MenuBorderLines] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5464,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMenuBorderLines","product":"core","slug":"tmux-globalwindowscope-setmenuborderlines"},{"id":"tmux.Window.SetMenuBorderStyle","name":"SetMenuBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuBorderStyle stores the \"menu-border-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuBorderStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5472,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMenuBorderStyle","product":"core","slug":"tmux-window-setmenuborderstyle"},{"id":"tmux.GlobalWindowScope.SetMenuBorderStyle","name":"SetMenuBorderStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuBorderStyle stores the \"menu-border-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuBorderStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5482,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMenuBorderStyle","product":"core","slug":"tmux-globalwindowscope-setmenuborderstyle"},{"id":"tmux.Window.SetMenuSelectedStyle","name":"SetMenuSelectedStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuSelectedStyle stores the \"menu-selected-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuSelectedStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5490,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMenuSelectedStyle","product":"core","slug":"tmux-window-setmenuselectedstyle"},{"id":"tmux.GlobalWindowScope.SetMenuSelectedStyle","name":"SetMenuSelectedStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuSelectedStyle stores the \"menu-selected-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuSelectedStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5500,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMenuSelectedStyle","product":"core","slug":"tmux-globalwindowscope-setmenuselectedstyle"},{"id":"tmux.Window.SetMenuStyle","name":"SetMenuStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuStyle stores the \"menu-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5508,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMenuStyle","product":"core","slug":"tmux-window-setmenustyle"},{"id":"tmux.GlobalWindowScope.SetMenuStyle","name":"SetMenuStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMenuStyle stores the \"menu-style\" window option as string (tmux 3.4 or later). Read it with [WindowOptionValues.MenuStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5518,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMenuStyle","product":"core","slug":"tmux-globalwindowscope-setmenustyle"},{"id":"tmux.Session.SetMessageCommandStyle","name":"SetMessageCommandStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageCommandStyle stores the \"message-command-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.MessageCommandStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5526,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetMessageCommandStyle","product":"core","slug":"tmux-session-setmessagecommandstyle"},{"id":"tmux.GlobalSessionScope.SetMessageCommandStyle","name":"SetMessageCommandStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageCommandStyle stores the \"message-command-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.MessageCommandStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5536,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetMessageCommandStyle","product":"core","slug":"tmux-globalsessionscope-setmessagecommandstyle"},{"id":"tmux.Session.SetMessageFormat","name":"SetMessageFormat","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageFormat stores the \"message-format\" session option as string (tmux 3.7 or later). Read it with [SessionOptionValues.MessageFormat] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5544,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetMessageFormat","product":"core","slug":"tmux-session-setmessageformat"},{"id":"tmux.GlobalSessionScope.SetMessageFormat","name":"SetMessageFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageFormat stores the \"message-format\" session option as string (tmux 3.7 or later). Read it with [SessionOptionValues.MessageFormat] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5554,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetMessageFormat","product":"core","slug":"tmux-globalsessionscope-setmessageformat"},{"id":"tmux.Server.SetMessageLimit","name":"SetMessageLimit","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetMessageLimit stores the \"message-limit\" server option as int64 (tmux 3.2a or later). Read it with [ServerOptionValues.MessageLimit] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5562,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetMessageLimit","product":"core","slug":"tmux-server-setmessagelimit"},{"id":"tmux.Session.SetMessageLine","name":"SetMessageLine","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"MessageLine"}],"returns":"error"}],"doc":{"summary":"SetMessageLine stores the \"message-line\" session option as MessageLine (tmux 3.4 or later). Read it with [SessionOptionValues.MessageLine] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5570,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetMessageLine","product":"core","slug":"tmux-session-setmessageline"},{"id":"tmux.GlobalSessionScope.SetMessageLine","name":"SetMessageLine","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"MessageLine"}],"returns":"error"}],"doc":{"summary":"SetMessageLine stores the \"message-line\" session option as MessageLine (tmux 3.4 or later). Read it with [SessionOptionValues.MessageLine] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5580,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetMessageLine","product":"core","slug":"tmux-globalsessionscope-setmessageline"},{"id":"tmux.Session.SetMessageStyle","name":"SetMessageStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageStyle stores the \"message-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.MessageStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5588,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetMessageStyle","product":"core","slug":"tmux-session-setmessagestyle"},{"id":"tmux.GlobalSessionScope.SetMessageStyle","name":"SetMessageStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetMessageStyle stores the \"message-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.MessageStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5598,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetMessageStyle","product":"core","slug":"tmux-globalsessionscope-setmessagestyle"},{"id":"tmux.Window.SetModeKeys","name":"SetModeKeys","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ModeKeys"}],"returns":"error"}],"doc":{"summary":"SetModeKeys stores the \"mode-keys\" window option as ModeKeys (tmux 3.2a or later). Read it with [WindowOptionValues.ModeKeys] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5606,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetModeKeys","product":"core","slug":"tmux-window-setmodekeys"},{"id":"tmux.GlobalWindowScope.SetModeKeys","name":"SetModeKeys","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"ModeKeys"}],"returns":"error"}],"doc":{"summary":"SetModeKeys stores the \"mode-keys\" window option as ModeKeys (tmux 3.2a or later). Read it with [WindowOptionValues.ModeKeys] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5616,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetModeKeys","product":"core","slug":"tmux-globalwindowscope-setmodekeys"},{"id":"tmux.Window.SetModeStyle","name":"SetModeStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetModeStyle stores the \"mode-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.ModeStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5624,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetModeStyle","product":"core","slug":"tmux-window-setmodestyle"},{"id":"tmux.GlobalWindowScope.SetModeStyle","name":"SetModeStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetModeStyle stores the \"mode-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.ModeStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5634,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetModeStyle","product":"core","slug":"tmux-globalwindowscope-setmodestyle"},{"id":"tmux.Window.SetMonitorActivity","name":"SetMonitorActivity","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMonitorActivity stores the \"monitor-activity\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorActivity] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5642,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMonitorActivity","product":"core","slug":"tmux-window-setmonitoractivity"},{"id":"tmux.GlobalWindowScope.SetMonitorActivity","name":"SetMonitorActivity","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMonitorActivity stores the \"monitor-activity\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorActivity] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5652,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMonitorActivity","product":"core","slug":"tmux-globalwindowscope-setmonitoractivity"},{"id":"tmux.Window.SetMonitorBell","name":"SetMonitorBell","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMonitorBell stores the \"monitor-bell\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorBell] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5660,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMonitorBell","product":"core","slug":"tmux-window-setmonitorbell"},{"id":"tmux.GlobalWindowScope.SetMonitorBell","name":"SetMonitorBell","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMonitorBell stores the \"monitor-bell\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorBell] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5670,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMonitorBell","product":"core","slug":"tmux-globalwindowscope-setmonitorbell"},{"id":"tmux.Window.SetMonitorSilence","name":"SetMonitorSilence","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetMonitorSilence stores the \"monitor-silence\" window option as int64 (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorSilence] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5678,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetMonitorSilence","product":"core","slug":"tmux-window-setmonitorsilence"},{"id":"tmux.GlobalWindowScope.SetMonitorSilence","name":"SetMonitorSilence","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetMonitorSilence stores the \"monitor-silence\" window option as int64 (tmux 3.2a or later). Read it with [WindowOptionValues.MonitorSilence] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5688,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetMonitorSilence","product":"core","slug":"tmux-globalwindowscope-setmonitorsilence"},{"id":"tmux.Session.SetMouse","name":"SetMouse","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMouse stores the \"mouse\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.Mouse] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5696,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetMouse","product":"core","slug":"tmux-session-setmouse"},{"id":"tmux.GlobalSessionScope.SetMouse","name":"SetMouse","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetMouse stores the \"mouse\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.Mouse] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5706,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetMouse","product":"core","slug":"tmux-globalsessionscope-setmouse"},{"id":"tmux.Window.SetOtherPaneHeight","name":"SetOtherPaneHeight","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetOtherPaneHeight stores the \"other-pane-height\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.OtherPaneHeight] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5714,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetOtherPaneHeight","product":"core","slug":"tmux-window-setotherpaneheight"},{"id":"tmux.GlobalWindowScope.SetOtherPaneHeight","name":"SetOtherPaneHeight","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetOtherPaneHeight stores the \"other-pane-height\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.OtherPaneHeight] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5724,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetOtherPaneHeight","product":"core","slug":"tmux-globalwindowscope-setotherpaneheight"},{"id":"tmux.Window.SetOtherPaneWidth","name":"SetOtherPaneWidth","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetOtherPaneWidth stores the \"other-pane-width\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.OtherPaneWidth] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5732,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetOtherPaneWidth","product":"core","slug":"tmux-window-setotherpanewidth"},{"id":"tmux.GlobalWindowScope.SetOtherPaneWidth","name":"SetOtherPaneWidth","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetOtherPaneWidth stores the \"other-pane-width\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.OtherPaneWidth] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5742,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetOtherPaneWidth","product":"core","slug":"tmux-globalwindowscope-setotherpanewidth"},{"id":"tmux.Window.SetPaneActiveBorderStyle","name":"SetPaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneActiveBorderStyle stores the \"pane-active-border-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneActiveBorderStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5750,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneActiveBorderStyle","product":"core","slug":"tmux-window-setpaneactiveborderstyle"},{"id":"tmux.GlobalWindowScope.SetPaneActiveBorderStyle","name":"SetPaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneActiveBorderStyle stores the \"pane-active-border-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneActiveBorderStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5760,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneActiveBorderStyle","product":"core","slug":"tmux-globalwindowscope-setpaneactiveborderstyle"},{"id":"tmux.Pane.SetPaneActiveBorderStyle","name":"SetPaneActiveBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneActiveBorderStyle stores the \"pane-active-border-style\" pane option as string (tmux 3.7 or later). Read it with [PaneOptionValues.PaneActiveBorderStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5768,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetPaneActiveBorderStyle","product":"core","slug":"tmux-pane-setpaneactiveborderstyle"},{"id":"tmux.Window.SetPaneBaseIndex","name":"SetPaneBaseIndex","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetPaneBaseIndex stores the \"pane-base-index\" window option as int64 (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBaseIndex] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5778,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneBaseIndex","product":"core","slug":"tmux-window-setpanebaseindex"},{"id":"tmux.GlobalWindowScope.SetPaneBaseIndex","name":"SetPaneBaseIndex","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetPaneBaseIndex stores the \"pane-base-index\" window option as int64 (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBaseIndex] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5788,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneBaseIndex","product":"core","slug":"tmux-globalwindowscope-setpanebaseindex"},{"id":"tmux.Window.SetPaneBorderFormat","name":"SetPaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderFormat stores the \"pane-border-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5796,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneBorderFormat","product":"core","slug":"tmux-window-setpaneborderformat"},{"id":"tmux.GlobalWindowScope.SetPaneBorderFormat","name":"SetPaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderFormat stores the \"pane-border-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5806,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderFormat","product":"core","slug":"tmux-globalwindowscope-setpaneborderformat"},{"id":"tmux.Pane.SetPaneBorderFormat","name":"SetPaneBorderFormat","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderFormat stores the \"pane-border-format\" pane option as string (tmux 3.3 or later). Read it with [PaneOptionValues.PaneBorderFormat] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5814,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetPaneBorderFormat","product":"core","slug":"tmux-pane-setpaneborderformat"},{"id":"tmux.Window.SetPaneBorderIndicators","name":"SetPaneBorderIndicators","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderIndicators"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderIndicators stores the \"pane-border-indicators\" window option as PaneBorderIndicators (tmux 3.3 or later). Read it with [WindowOptionValues.PaneBorderIndicators] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5824,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneBorderIndicators","product":"core","slug":"tmux-window-setpaneborderindicators"},{"id":"tmux.GlobalWindowScope.SetPaneBorderIndicators","name":"SetPaneBorderIndicators","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderIndicators"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderIndicators stores the \"pane-border-indicators\" window option as PaneBorderIndicators (tmux 3.3 or later). Read it with [WindowOptionValues.PaneBorderIndicators] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5834,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderIndicators","product":"core","slug":"tmux-globalwindowscope-setpaneborderindicators"},{"id":"tmux.Window.SetPaneBorderLines","name":"SetPaneBorderLines","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderLines"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderLines stores the \"pane-border-lines\" window option as PaneBorderLines (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderLines] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5842,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneBorderLines","product":"core","slug":"tmux-window-setpaneborderlines"},{"id":"tmux.GlobalWindowScope.SetPaneBorderLines","name":"SetPaneBorderLines","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderLines"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderLines stores the \"pane-border-lines\" window option as PaneBorderLines (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderLines] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5852,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderLines","product":"core","slug":"tmux-globalwindowscope-setpaneborderlines"},{"id":"tmux.Window.SetPaneBorderStatus","name":"SetPaneBorderStatus","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderStatus"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStatus stores the \"pane-border-status\" window option as PaneBorderStatus (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderStatus] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5860,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneBorderStatus","product":"core","slug":"tmux-window-setpaneborderstatus"},{"id":"tmux.GlobalWindowScope.SetPaneBorderStatus","name":"SetPaneBorderStatus","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneBorderStatus"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStatus stores the \"pane-border-status\" window option as PaneBorderStatus (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderStatus] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5870,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderStatus","product":"core","slug":"tmux-globalwindowscope-setpaneborderstatus"},{"id":"tmux.Window.SetPaneBorderStyle","name":"SetPaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStyle stores the \"pane-border-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5878,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneBorderStyle","product":"core","slug":"tmux-window-setpaneborderstyle"},{"id":"tmux.GlobalWindowScope.SetPaneBorderStyle","name":"SetPaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStyle stores the \"pane-border-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.PaneBorderStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5888,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneBorderStyle","product":"core","slug":"tmux-globalwindowscope-setpaneborderstyle"},{"id":"tmux.Pane.SetPaneBorderStyle","name":"SetPaneBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneBorderStyle stores the \"pane-border-style\" pane option as string (tmux 3.7 or later). Read it with [PaneOptionValues.PaneBorderStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5896,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetPaneBorderStyle","product":"core","slug":"tmux-pane-setpaneborderstyle"},{"id":"tmux.Window.SetPaneScrollbars","name":"SetPaneScrollbars","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneScrollbars"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbars stores the \"pane-scrollbars\" window option as PaneScrollbars (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbars] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5906,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneScrollbars","product":"core","slug":"tmux-window-setpanescrollbars"},{"id":"tmux.GlobalWindowScope.SetPaneScrollbars","name":"SetPaneScrollbars","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneScrollbars"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbars stores the \"pane-scrollbars\" window option as PaneScrollbars (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbars] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5916,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneScrollbars","product":"core","slug":"tmux-globalwindowscope-setpanescrollbars"},{"id":"tmux.Window.SetPaneScrollbarsPosition","name":"SetPaneScrollbarsPosition","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneScrollbarsPosition"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsPosition stores the \"pane-scrollbars-position\" window option as PaneScrollbarsPosition (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbarsPosition] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5924,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneScrollbarsPosition","product":"core","slug":"tmux-window-setpanescrollbarsposition"},{"id":"tmux.GlobalWindowScope.SetPaneScrollbarsPosition","name":"SetPaneScrollbarsPosition","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PaneScrollbarsPosition"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsPosition stores the \"pane-scrollbars-position\" window option as PaneScrollbarsPosition (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbarsPosition] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5934,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneScrollbarsPosition","product":"core","slug":"tmux-globalwindowscope-setpanescrollbarsposition"},{"id":"tmux.Window.SetPaneScrollbarsStyle","name":"SetPaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsStyle stores the \"pane-scrollbars-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbarsStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5942,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneScrollbarsStyle","product":"core","slug":"tmux-window-setpanescrollbarsstyle"},{"id":"tmux.GlobalWindowScope.SetPaneScrollbarsStyle","name":"SetPaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsStyle stores the \"pane-scrollbars-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneScrollbarsStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5952,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneScrollbarsStyle","product":"core","slug":"tmux-globalwindowscope-setpanescrollbarsstyle"},{"id":"tmux.Pane.SetPaneScrollbarsStyle","name":"SetPaneScrollbarsStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneScrollbarsStyle stores the \"pane-scrollbars-style\" pane option as string (tmux 3.6 or later). Read it with [PaneOptionValues.PaneScrollbarsStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5960,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetPaneScrollbarsStyle","product":"core","slug":"tmux-pane-setpanescrollbarsstyle"},{"id":"tmux.Window.SetPaneStatusCurrentStyle","name":"SetPaneStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneStatusCurrentStyle stores the \"pane-status-current-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneStatusCurrentStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5970,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneStatusCurrentStyle","product":"core","slug":"tmux-window-setpanestatuscurrentstyle"},{"id":"tmux.GlobalWindowScope.SetPaneStatusCurrentStyle","name":"SetPaneStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneStatusCurrentStyle stores the \"pane-status-current-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneStatusCurrentStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5980,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneStatusCurrentStyle","product":"core","slug":"tmux-globalwindowscope-setpanestatuscurrentstyle"},{"id":"tmux.Window.SetPaneStatusStyle","name":"SetPaneStatusStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneStatusStyle stores the \"pane-status-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneStatusStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5988,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneStatusStyle","product":"core","slug":"tmux-window-setpanestatusstyle"},{"id":"tmux.GlobalWindowScope.SetPaneStatusStyle","name":"SetPaneStatusStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPaneStatusStyle stores the \"pane-status-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.PaneStatusStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":5998,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneStatusStyle","product":"core","slug":"tmux-globalwindowscope-setpanestatusstyle"},{"id":"tmux.Window.SetPopupBorderLines","name":"SetPopupBorderLines","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PopupBorderLines"}],"returns":"error"}],"doc":{"summary":"SetPopupBorderLines stores the \"popup-border-lines\" window option as PopupBorderLines (tmux 3.3 or later). Read it with [WindowOptionValues.PopupBorderLines] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6006,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPopupBorderLines","product":"core","slug":"tmux-window-setpopupborderlines"},{"id":"tmux.GlobalWindowScope.SetPopupBorderLines","name":"SetPopupBorderLines","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PopupBorderLines"}],"returns":"error"}],"doc":{"summary":"SetPopupBorderLines stores the \"popup-border-lines\" window option as PopupBorderLines (tmux 3.3 or later). Read it with [WindowOptionValues.PopupBorderLines] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6016,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPopupBorderLines","product":"core","slug":"tmux-globalwindowscope-setpopupborderlines"},{"id":"tmux.Window.SetPopupBorderStyle","name":"SetPopupBorderStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPopupBorderStyle stores the \"popup-border-style\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.PopupBorderStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6024,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPopupBorderStyle","product":"core","slug":"tmux-window-setpopupborderstyle"},{"id":"tmux.GlobalWindowScope.SetPopupBorderStyle","name":"SetPopupBorderStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPopupBorderStyle stores the \"popup-border-style\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.PopupBorderStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6034,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPopupBorderStyle","product":"core","slug":"tmux-globalwindowscope-setpopupborderstyle"},{"id":"tmux.Window.SetPopupStyle","name":"SetPopupStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPopupStyle stores the \"popup-style\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.PopupStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6042,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPopupStyle","product":"core","slug":"tmux-window-setpopupstyle"},{"id":"tmux.GlobalWindowScope.SetPopupStyle","name":"SetPopupStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPopupStyle stores the \"popup-style\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.PopupStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6052,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPopupStyle","product":"core","slug":"tmux-globalwindowscope-setpopupstyle"},{"id":"tmux.Session.SetPrefix","name":"SetPrefix","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPrefix stores the \"prefix\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.Prefix] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6060,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetPrefix","product":"core","slug":"tmux-session-setprefix"},{"id":"tmux.GlobalSessionScope.SetPrefix","name":"SetPrefix","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPrefix stores the \"prefix\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.Prefix] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6070,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetPrefix","product":"core","slug":"tmux-globalsessionscope-setprefix"},{"id":"tmux.Server.SetPrefixTimeout","name":"SetPrefixTimeout","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetPrefixTimeout stores the \"prefix-timeout\" server option as time.Duration (tmux 3.5 or later). Read it with [ServerOptionValues.PrefixTimeout] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6078,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetPrefixTimeout","product":"core","slug":"tmux-server-setprefixtimeout"},{"id":"tmux.Session.SetPrefix2","name":"SetPrefix2","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPrefix2 stores the \"prefix2\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.Prefix2] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6090,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetPrefix2","product":"core","slug":"tmux-session-setprefix2"},{"id":"tmux.GlobalSessionScope.SetPrefix2","name":"SetPrefix2","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPrefix2 stores the \"prefix2\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.Prefix2] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetPrefix2","product":"core","slug":"tmux-globalsessionscope-setprefix2"},{"id":"tmux.Session.SetPromptCommandCursorStyle","name":"SetPromptCommandCursorStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PromptCommandCursorStyle"}],"returns":"error"}],"doc":{"summary":"SetPromptCommandCursorStyle stores the \"prompt-command-cursor-style\" session option as PromptCommandCursorStyle (tmux 3.7 or later). Read it with [SessionOptionValues.PromptCommandCursorStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetPromptCommandCursorStyle","product":"core","slug":"tmux-session-setpromptcommandcursorstyle"},{"id":"tmux.GlobalSessionScope.SetPromptCommandCursorStyle","name":"SetPromptCommandCursorStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PromptCommandCursorStyle"}],"returns":"error"}],"doc":{"summary":"SetPromptCommandCursorStyle stores the \"prompt-command-cursor-style\" session option as PromptCommandCursorStyle (tmux 3.7 or later). Read it with [SessionOptionValues.PromptCommandCursorStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetPromptCommandCursorStyle","product":"core","slug":"tmux-globalsessionscope-setpromptcommandcursorstyle"},{"id":"tmux.Session.SetPromptCursorColour","name":"SetPromptCursorColour","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPromptCursorColour stores the \"prompt-cursor-colour\" session option as string (tmux 3.6 or later). Read it with [SessionOptionValues.PromptCursorColour] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6126,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetPromptCursorColour","product":"core","slug":"tmux-session-setpromptcursorcolour"},{"id":"tmux.GlobalSessionScope.SetPromptCursorColour","name":"SetPromptCursorColour","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetPromptCursorColour stores the \"prompt-cursor-colour\" session option as string (tmux 3.6 or later). Read it with [SessionOptionValues.PromptCursorColour] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6136,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetPromptCursorColour","product":"core","slug":"tmux-globalsessionscope-setpromptcursorcolour"},{"id":"tmux.Session.SetPromptCursorStyle","name":"SetPromptCursorStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PromptCursorStyle"}],"returns":"error"}],"doc":{"summary":"SetPromptCursorStyle stores the \"prompt-cursor-style\" session option as PromptCursorStyle (tmux 3.6 or later). Read it with [SessionOptionValues.PromptCursorStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetPromptCursorStyle","product":"core","slug":"tmux-session-setpromptcursorstyle"},{"id":"tmux.GlobalSessionScope.SetPromptCursorStyle","name":"SetPromptCursorStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"PromptCursorStyle"}],"returns":"error"}],"doc":{"summary":"SetPromptCursorStyle stores the \"prompt-cursor-style\" session option as PromptCursorStyle (tmux 3.6 or later). Read it with [SessionOptionValues.PromptCursorStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6154,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetPromptCursorStyle","product":"core","slug":"tmux-globalsessionscope-setpromptcursorstyle"},{"id":"tmux.Server.SetPromptHistoryLimit","name":"SetPromptHistoryLimit","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetPromptHistoryLimit stores the \"prompt-history-limit\" server option as int64 (tmux 3.3 or later). Read it with [ServerOptionValues.PromptHistoryLimit] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6162,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetPromptHistoryLimit","product":"core","slug":"tmux-server-setprompthistorylimit"},{"id":"tmux.Window.SetRemainOnExit","name":"SetRemainOnExit","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"RemainOnExit"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExit stores the \"remain-on-exit\" window option as RemainOnExit (tmux 3.2a or later). Read it with [WindowOptionValues.RemainOnExit] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6170,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetRemainOnExit","product":"core","slug":"tmux-window-setremainonexit"},{"id":"tmux.GlobalWindowScope.SetRemainOnExit","name":"SetRemainOnExit","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"RemainOnExit"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExit stores the \"remain-on-exit\" window option as RemainOnExit (tmux 3.2a or later). Read it with [WindowOptionValues.RemainOnExit] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6180,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetRemainOnExit","product":"core","slug":"tmux-globalwindowscope-setremainonexit"},{"id":"tmux.Pane.SetRemainOnExit","name":"SetRemainOnExit","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"RemainOnExit"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExit stores the \"remain-on-exit\" pane option as RemainOnExit (tmux 3.2a or later). Read it with [PaneOptionValues.RemainOnExit] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6188,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetRemainOnExit","product":"core","slug":"tmux-pane-setremainonexit"},{"id":"tmux.Window.SetRemainOnExitFormat","name":"SetRemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExitFormat stores the \"remain-on-exit-format\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.RemainOnExitFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6198,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetRemainOnExitFormat","product":"core","slug":"tmux-window-setremainonexitformat"},{"id":"tmux.GlobalWindowScope.SetRemainOnExitFormat","name":"SetRemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExitFormat stores the \"remain-on-exit-format\" window option as string (tmux 3.3 or later). Read it with [WindowOptionValues.RemainOnExitFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6208,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetRemainOnExitFormat","product":"core","slug":"tmux-globalwindowscope-setremainonexitformat"},{"id":"tmux.Pane.SetRemainOnExitFormat","name":"SetRemainOnExitFormat","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetRemainOnExitFormat stores the \"remain-on-exit-format\" pane option as string (tmux 3.3 or later). Read it with [PaneOptionValues.RemainOnExitFormat] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6216,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetRemainOnExitFormat","product":"core","slug":"tmux-pane-setremainonexitformat"},{"id":"tmux.Session.SetRenumberWindows","name":"SetRenumberWindows","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetRenumberWindows stores the \"renumber-windows\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.RenumberWindows] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6226,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetRenumberWindows","product":"core","slug":"tmux-session-setrenumberwindows"},{"id":"tmux.GlobalSessionScope.SetRenumberWindows","name":"SetRenumberWindows","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetRenumberWindows stores the \"renumber-windows\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.RenumberWindows] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6236,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetRenumberWindows","product":"core","slug":"tmux-globalsessionscope-setrenumberwindows"},{"id":"tmux.Session.SetRepeatTime","name":"SetRepeatTime","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetRepeatTime stores the \"repeat-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.RepeatTime] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6244,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetRepeatTime","product":"core","slug":"tmux-session-setrepeattime"},{"id":"tmux.GlobalSessionScope.SetRepeatTime","name":"SetRepeatTime","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetRepeatTime stores the \"repeat-time\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.RepeatTime] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6258,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetRepeatTime","product":"core","slug":"tmux-globalsessionscope-setrepeattime"},{"id":"tmux.Window.SetScrollOnClear","name":"SetScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetScrollOnClear stores the \"scroll-on-clear\" window option as bool (tmux 3.3 or later). Read it with [WindowOptionValues.ScrollOnClear] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6270,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetScrollOnClear","product":"core","slug":"tmux-window-setscrollonclear"},{"id":"tmux.GlobalWindowScope.SetScrollOnClear","name":"SetScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetScrollOnClear stores the \"scroll-on-clear\" window option as bool (tmux 3.3 or later). Read it with [WindowOptionValues.ScrollOnClear] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6280,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetScrollOnClear","product":"core","slug":"tmux-globalwindowscope-setscrollonclear"},{"id":"tmux.Pane.SetScrollOnClear","name":"SetScrollOnClear","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetScrollOnClear stores the \"scroll-on-clear\" pane option as bool (tmux 3.3 or later). Read it with [PaneOptionValues.ScrollOnClear] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6288,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetScrollOnClear","product":"core","slug":"tmux-pane-setscrollonclear"},{"id":"tmux.Window.SetSessionStatusCurrentStyle","name":"SetSessionStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetSessionStatusCurrentStyle stores the \"session-status-current-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.SessionStatusCurrentStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6298,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetSessionStatusCurrentStyle","product":"core","slug":"tmux-window-setsessionstatuscurrentstyle"},{"id":"tmux.GlobalWindowScope.SetSessionStatusCurrentStyle","name":"SetSessionStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetSessionStatusCurrentStyle stores the \"session-status-current-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.SessionStatusCurrentStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6308,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetSessionStatusCurrentStyle","product":"core","slug":"tmux-globalwindowscope-setsessionstatuscurrentstyle"},{"id":"tmux.Window.SetSessionStatusStyle","name":"SetSessionStatusStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetSessionStatusStyle stores the \"session-status-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.SessionStatusStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6316,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetSessionStatusStyle","product":"core","slug":"tmux-window-setsessionstatusstyle"},{"id":"tmux.GlobalWindowScope.SetSessionStatusStyle","name":"SetSessionStatusStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetSessionStatusStyle stores the \"session-status-style\" window option as string (tmux 3.6 or later). Read it with [WindowOptionValues.SessionStatusStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6326,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetSessionStatusStyle","product":"core","slug":"tmux-globalwindowscope-setsessionstatusstyle"},{"id":"tmux.Server.SetClipboard","name":"SetClipboard","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SetClipboard"}],"returns":"error"}],"doc":{"summary":"SetClipboard stores the \"set-clipboard\" server option as SetClipboard (tmux 3.2a or later). Read it with [ServerOptionValues.SetClipboard] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6334,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetClipboard","product":"core","slug":"tmux-server-setclipboard"},{"id":"tmux.Session.SetTitles","name":"SetTitles","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetTitles stores the \"set-titles\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.SetTitles] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6342,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetTitles","product":"core","slug":"tmux-session-settitles"},{"id":"tmux.GlobalSessionScope.SetTitles","name":"SetTitles","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetTitles stores the \"set-titles\" session option as bool (tmux 3.2a or later). Read it with [SessionOptionValues.SetTitles] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6352,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetTitles","product":"core","slug":"tmux-globalsessionscope-settitles"},{"id":"tmux.Session.SetTitlesString","name":"SetTitlesString","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTitlesString stores the \"set-titles-string\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.SetTitlesString] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6360,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetTitlesString","product":"core","slug":"tmux-session-settitlesstring"},{"id":"tmux.GlobalSessionScope.SetTitlesString","name":"SetTitlesString","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTitlesString stores the \"set-titles-string\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.SetTitlesString] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6370,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetTitlesString","product":"core","slug":"tmux-globalsessionscope-settitlesstring"},{"id":"tmux.Session.SetSilenceAction","name":"SetSilenceAction","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SilenceAction"}],"returns":"error"}],"doc":{"summary":"SetSilenceAction stores the \"silence-action\" session option as SilenceAction (tmux 3.2a or later). Read it with [SessionOptionValues.SilenceAction] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6378,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetSilenceAction","product":"core","slug":"tmux-session-setsilenceaction"},{"id":"tmux.GlobalSessionScope.SetSilenceAction","name":"SetSilenceAction","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SilenceAction"}],"returns":"error"}],"doc":{"summary":"SetSilenceAction stores the \"silence-action\" session option as SilenceAction (tmux 3.2a or later). Read it with [SessionOptionValues.SilenceAction] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6388,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetSilenceAction","product":"core","slug":"tmux-globalsessionscope-setsilenceaction"},{"id":"tmux.Session.SetStatus","name":"SetStatus","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"Status"}],"returns":"error"}],"doc":{"summary":"SetStatus stores the \"status\" session option as Status (tmux 3.2a or later). Read it with [SessionOptionValues.Status] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6396,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatus","product":"core","slug":"tmux-session-setstatus"},{"id":"tmux.GlobalSessionScope.SetStatus","name":"SetStatus","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"Status"}],"returns":"error"}],"doc":{"summary":"SetStatus stores the \"status\" session option as Status (tmux 3.2a or later). Read it with [SessionOptionValues.Status] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6406,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatus","product":"core","slug":"tmux-globalsessionscope-setstatus"},{"id":"tmux.Session.SetStatusBG","name":"SetStatusBG","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusBG stores the \"status-bg\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusBG] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6414,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusBG","product":"core","slug":"tmux-session-setstatusbg"},{"id":"tmux.GlobalSessionScope.SetStatusBG","name":"SetStatusBG","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusBG stores the \"status-bg\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusBG] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6424,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusBG","product":"core","slug":"tmux-globalsessionscope-setstatusbg"},{"id":"tmux.Session.SetStatusFG","name":"SetStatusFG","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusFG stores the \"status-fg\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusFG] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6432,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusFG","product":"core","slug":"tmux-session-setstatusfg"},{"id":"tmux.GlobalSessionScope.SetStatusFG","name":"SetStatusFG","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusFG stores the \"status-fg\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusFG] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6442,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusFG","product":"core","slug":"tmux-globalsessionscope-setstatusfg"},{"id":"tmux.Session.SetStatusInterval","name":"SetStatusInterval","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetStatusInterval stores the \"status-interval\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.StatusInterval] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6450,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusInterval","product":"core","slug":"tmux-session-setstatusinterval"},{"id":"tmux.GlobalSessionScope.SetStatusInterval","name":"SetStatusInterval","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"time.Duration"}],"returns":"error"}],"doc":{"summary":"SetStatusInterval stores the \"status-interval\" session option as time.Duration (tmux 3.2a or later). Read it with [SessionOptionValues.StatusInterval] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6464,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusInterval","product":"core","slug":"tmux-globalsessionscope-setstatusinterval"},{"id":"tmux.Session.SetStatusJustify","name":"SetStatusJustify","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusJustify"}],"returns":"error"}],"doc":{"summary":"SetStatusJustify stores the \"status-justify\" session option as StatusJustify (tmux 3.2a or later). Read it with [SessionOptionValues.StatusJustify] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6476,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusJustify","product":"core","slug":"tmux-session-setstatusjustify"},{"id":"tmux.GlobalSessionScope.SetStatusJustify","name":"SetStatusJustify","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusJustify"}],"returns":"error"}],"doc":{"summary":"SetStatusJustify stores the \"status-justify\" session option as StatusJustify (tmux 3.2a or later). Read it with [SessionOptionValues.StatusJustify] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6486,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusJustify","product":"core","slug":"tmux-globalsessionscope-setstatusjustify"},{"id":"tmux.Session.SetStatusKeys","name":"SetStatusKeys","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusKeys"}],"returns":"error"}],"doc":{"summary":"SetStatusKeys stores the \"status-keys\" session option as StatusKeys (tmux 3.2a or later). Read it with [SessionOptionValues.StatusKeys] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6494,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusKeys","product":"core","slug":"tmux-session-setstatuskeys"},{"id":"tmux.GlobalSessionScope.SetStatusKeys","name":"SetStatusKeys","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusKeys"}],"returns":"error"}],"doc":{"summary":"SetStatusKeys stores the \"status-keys\" session option as StatusKeys (tmux 3.2a or later). Read it with [SessionOptionValues.StatusKeys] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6504,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusKeys","product":"core","slug":"tmux-globalsessionscope-setstatuskeys"},{"id":"tmux.Session.SetStatusLeft","name":"SetStatusLeft","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusLeft stores the \"status-left\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeft] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6512,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusLeft","product":"core","slug":"tmux-session-setstatusleft"},{"id":"tmux.GlobalSessionScope.SetStatusLeft","name":"SetStatusLeft","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusLeft stores the \"status-left\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeft] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6522,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusLeft","product":"core","slug":"tmux-globalsessionscope-setstatusleft"},{"id":"tmux.Session.SetStatusLeftLength","name":"SetStatusLeftLength","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetStatusLeftLength stores the \"status-left-length\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeftLength] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6530,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusLeftLength","product":"core","slug":"tmux-session-setstatusleftlength"},{"id":"tmux.GlobalSessionScope.SetStatusLeftLength","name":"SetStatusLeftLength","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetStatusLeftLength stores the \"status-left-length\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeftLength] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6540,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusLeftLength","product":"core","slug":"tmux-globalsessionscope-setstatusleftlength"},{"id":"tmux.Session.SetStatusLeftStyle","name":"SetStatusLeftStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusLeftStyle stores the \"status-left-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeftStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6548,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusLeftStyle","product":"core","slug":"tmux-session-setstatusleftstyle"},{"id":"tmux.GlobalSessionScope.SetStatusLeftStyle","name":"SetStatusLeftStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusLeftStyle stores the \"status-left-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusLeftStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6558,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusLeftStyle","product":"core","slug":"tmux-globalsessionscope-setstatusleftstyle"},{"id":"tmux.Session.SetStatusPosition","name":"SetStatusPosition","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusPosition"}],"returns":"error"}],"doc":{"summary":"SetStatusPosition stores the \"status-position\" session option as StatusPosition (tmux 3.2a or later). Read it with [SessionOptionValues.StatusPosition] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6566,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusPosition","product":"core","slug":"tmux-session-setstatusposition"},{"id":"tmux.GlobalSessionScope.SetStatusPosition","name":"SetStatusPosition","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"StatusPosition"}],"returns":"error"}],"doc":{"summary":"SetStatusPosition stores the \"status-position\" session option as StatusPosition (tmux 3.2a or later). Read it with [SessionOptionValues.StatusPosition] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6576,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusPosition","product":"core","slug":"tmux-globalsessionscope-setstatusposition"},{"id":"tmux.Session.SetStatusRight","name":"SetStatusRight","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusRight stores the \"status-right\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRight] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6584,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusRight","product":"core","slug":"tmux-session-setstatusright"},{"id":"tmux.GlobalSessionScope.SetStatusRight","name":"SetStatusRight","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusRight stores the \"status-right\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRight] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6594,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusRight","product":"core","slug":"tmux-globalsessionscope-setstatusright"},{"id":"tmux.Session.SetStatusRightLength","name":"SetStatusRightLength","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetStatusRightLength stores the \"status-right-length\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRightLength] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6602,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusRightLength","product":"core","slug":"tmux-session-setstatusrightlength"},{"id":"tmux.GlobalSessionScope.SetStatusRightLength","name":"SetStatusRightLength","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetStatusRightLength stores the \"status-right-length\" session option as int64 (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRightLength] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6612,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusRightLength","product":"core","slug":"tmux-globalsessionscope-setstatusrightlength"},{"id":"tmux.Session.SetStatusRightStyle","name":"SetStatusRightStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusRightStyle stores the \"status-right-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRightStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6620,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusRightStyle","product":"core","slug":"tmux-session-setstatusrightstyle"},{"id":"tmux.GlobalSessionScope.SetStatusRightStyle","name":"SetStatusRightStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusRightStyle stores the \"status-right-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusRightStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6630,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusRightStyle","product":"core","slug":"tmux-globalsessionscope-setstatusrightstyle"},{"id":"tmux.Session.SetStatusStyle","name":"SetStatusStyle","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusStyle stores the \"status-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusStyle] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6638,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusStyle","product":"core","slug":"tmux-session-setstatusstyle"},{"id":"tmux.GlobalSessionScope.SetStatusStyle","name":"SetStatusStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetStatusStyle stores the \"status-style\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.StatusStyle] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6648,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusStyle","product":"core","slug":"tmux-globalsessionscope-setstatusstyle"},{"id":"tmux.Window.SetSynchronizePanes","name":"SetSynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetSynchronizePanes stores the \"synchronize-panes\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.SynchronizePanes] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6656,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetSynchronizePanes","product":"core","slug":"tmux-window-setsynchronizepanes"},{"id":"tmux.GlobalWindowScope.SetSynchronizePanes","name":"SetSynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetSynchronizePanes stores the \"synchronize-panes\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.SynchronizePanes] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6666,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetSynchronizePanes","product":"core","slug":"tmux-globalwindowscope-setsynchronizepanes"},{"id":"tmux.Pane.SetSynchronizePanes","name":"SetSynchronizePanes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetSynchronizePanes stores the \"synchronize-panes\" pane option as bool (tmux 3.2a or later). Read it with [PaneOptionValues.SynchronizePanes] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6674,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetSynchronizePanes","product":"core","slug":"tmux-pane-setsynchronizepanes"},{"id":"tmux.Window.SetTiledLayoutMaxColumns","name":"SetTiledLayoutMaxColumns","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetTiledLayoutMaxColumns stores the \"tiled-layout-max-columns\" window option as int64 (tmux 3.6 or later). Read it with [WindowOptionValues.TiledLayoutMaxColumns] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6684,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetTiledLayoutMaxColumns","product":"core","slug":"tmux-window-settiledlayoutmaxcolumns"},{"id":"tmux.GlobalWindowScope.SetTiledLayoutMaxColumns","name":"SetTiledLayoutMaxColumns","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"int64"}],"returns":"error"}],"doc":{"summary":"SetTiledLayoutMaxColumns stores the \"tiled-layout-max-columns\" window option as int64 (tmux 3.6 or later). Read it with [WindowOptionValues.TiledLayoutMaxColumns] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6694,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetTiledLayoutMaxColumns","product":"core","slug":"tmux-globalwindowscope-settiledlayoutmaxcolumns"},{"id":"tmux.Window.SetTreeModePreviewFormat","name":"SetTreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewFormat stores the \"tree-mode-preview-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.TreeModePreviewFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6702,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetTreeModePreviewFormat","product":"core","slug":"tmux-window-settreemodepreviewformat"},{"id":"tmux.GlobalWindowScope.SetTreeModePreviewFormat","name":"SetTreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewFormat stores the \"tree-mode-preview-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.TreeModePreviewFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6712,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetTreeModePreviewFormat","product":"core","slug":"tmux-globalwindowscope-settreemodepreviewformat"},{"id":"tmux.Pane.SetTreeModePreviewFormat","name":"SetTreeModePreviewFormat","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewFormat stores the \"tree-mode-preview-format\" pane option as string (tmux 3.7 or later). Read it with [PaneOptionValues.TreeModePreviewFormat] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6720,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetTreeModePreviewFormat","product":"core","slug":"tmux-pane-settreemodepreviewformat"},{"id":"tmux.Window.SetTreeModePreviewStyle","name":"SetTreeModePreviewStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewStyle stores the \"tree-mode-preview-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.TreeModePreviewStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6730,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetTreeModePreviewStyle","product":"core","slug":"tmux-window-settreemodepreviewstyle"},{"id":"tmux.GlobalWindowScope.SetTreeModePreviewStyle","name":"SetTreeModePreviewStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetTreeModePreviewStyle stores the \"tree-mode-preview-style\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.TreeModePreviewStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6740,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetTreeModePreviewStyle","product":"core","slug":"tmux-globalwindowscope-settreemodepreviewstyle"},{"id":"tmux.Server.SetVariationSelectorAlwaysWide","name":"SetVariationSelectorAlwaysWide","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetVariationSelectorAlwaysWide stores the \"variation-selector-always-wide\" server option as bool (tmux 3.6 or later). Read it with [ServerOptionValues.VariationSelectorAlwaysWide] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6748,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetVariationSelectorAlwaysWide","product":"core","slug":"tmux-server-setvariationselectoralwayswide"},{"id":"tmux.Session.SetVisualActivity","name":"SetVisualActivity","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualActivity"}],"returns":"error"}],"doc":{"summary":"SetVisualActivity stores the \"visual-activity\" session option as VisualActivity (tmux 3.2a or later). Read it with [SessionOptionValues.VisualActivity] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6756,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetVisualActivity","product":"core","slug":"tmux-session-setvisualactivity"},{"id":"tmux.GlobalSessionScope.SetVisualActivity","name":"SetVisualActivity","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualActivity"}],"returns":"error"}],"doc":{"summary":"SetVisualActivity stores the \"visual-activity\" session option as VisualActivity (tmux 3.2a or later). Read it with [SessionOptionValues.VisualActivity] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6766,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetVisualActivity","product":"core","slug":"tmux-globalsessionscope-setvisualactivity"},{"id":"tmux.Session.SetVisualBell","name":"SetVisualBell","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualBell"}],"returns":"error"}],"doc":{"summary":"SetVisualBell stores the \"visual-bell\" session option as VisualBell (tmux 3.2a or later). Read it with [SessionOptionValues.VisualBell] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6774,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetVisualBell","product":"core","slug":"tmux-session-setvisualbell"},{"id":"tmux.GlobalSessionScope.SetVisualBell","name":"SetVisualBell","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualBell"}],"returns":"error"}],"doc":{"summary":"SetVisualBell stores the \"visual-bell\" session option as VisualBell (tmux 3.2a or later). Read it with [SessionOptionValues.VisualBell] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6784,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetVisualBell","product":"core","slug":"tmux-globalsessionscope-setvisualbell"},{"id":"tmux.Session.SetVisualSilence","name":"SetVisualSilence","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualSilence"}],"returns":"error"}],"doc":{"summary":"SetVisualSilence stores the \"visual-silence\" session option as VisualSilence (tmux 3.2a or later). Read it with [SessionOptionValues.VisualSilence] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6792,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetVisualSilence","product":"core","slug":"tmux-session-setvisualsilence"},{"id":"tmux.GlobalSessionScope.SetVisualSilence","name":"SetVisualSilence","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"VisualSilence"}],"returns":"error"}],"doc":{"summary":"SetVisualSilence stores the \"visual-silence\" session option as VisualSilence (tmux 3.2a or later). Read it with [SessionOptionValues.VisualSilence] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6802,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetVisualSilence","product":"core","slug":"tmux-globalsessionscope-setvisualsilence"},{"id":"tmux.Window.SetWindowActiveStyle","name":"SetWindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowActiveStyle stores the \"window-active-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowActiveStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6810,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowActiveStyle","product":"core","slug":"tmux-window-setwindowactivestyle"},{"id":"tmux.GlobalWindowScope.SetWindowActiveStyle","name":"SetWindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowActiveStyle stores the \"window-active-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowActiveStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6820,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowActiveStyle","product":"core","slug":"tmux-globalwindowscope-setwindowactivestyle"},{"id":"tmux.Pane.SetWindowActiveStyle","name":"SetWindowActiveStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowActiveStyle stores the \"window-active-style\" pane option as string (tmux 3.2a or later). Read it with [PaneOptionValues.WindowActiveStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6828,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetWindowActiveStyle","product":"core","slug":"tmux-pane-setwindowactivestyle"},{"id":"tmux.Window.SetWindowPaneCurrentStatusFormat","name":"SetWindowPaneCurrentStatusFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowPaneCurrentStatusFormat stores the \"window-pane-current-status-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.WindowPaneCurrentStatusFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6838,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowPaneCurrentStatusFormat","product":"core","slug":"tmux-window-setwindowpanecurrentstatusformat"},{"id":"tmux.GlobalWindowScope.SetWindowPaneCurrentStatusFormat","name":"SetWindowPaneCurrentStatusFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowPaneCurrentStatusFormat stores the \"window-pane-current-status-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.WindowPaneCurrentStatusFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6848,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowPaneCurrentStatusFormat","product":"core","slug":"tmux-globalwindowscope-setwindowpanecurrentstatusformat"},{"id":"tmux.Window.SetWindowPaneStatusFormat","name":"SetWindowPaneStatusFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowPaneStatusFormat stores the \"window-pane-status-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.WindowPaneStatusFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6856,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowPaneStatusFormat","product":"core","slug":"tmux-window-setwindowpanestatusformat"},{"id":"tmux.GlobalWindowScope.SetWindowPaneStatusFormat","name":"SetWindowPaneStatusFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowPaneStatusFormat stores the \"window-pane-status-format\" window option as string (tmux 3.7 or later). Read it with [WindowOptionValues.WindowPaneStatusFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6866,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowPaneStatusFormat","product":"core","slug":"tmux-globalwindowscope-setwindowpanestatusformat"},{"id":"tmux.Window.SetWindowSize","name":"SetWindowSize","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"WindowSize"}],"returns":"error"}],"doc":{"summary":"SetWindowSize stores the \"window-size\" window option as WindowSize (tmux 3.2a or later). Read it with [WindowOptionValues.WindowSize] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6874,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowSize","product":"core","slug":"tmux-window-setwindowsize"},{"id":"tmux.GlobalWindowScope.SetWindowSize","name":"SetWindowSize","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"WindowSize"}],"returns":"error"}],"doc":{"summary":"SetWindowSize stores the \"window-size\" window option as WindowSize (tmux 3.2a or later). Read it with [WindowOptionValues.WindowSize] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6884,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowSize","product":"core","slug":"tmux-globalwindowscope-setwindowsize"},{"id":"tmux.Window.SetWindowStatusActivityStyle","name":"SetWindowStatusActivityStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusActivityStyle stores the \"window-status-activity-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusActivityStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6892,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStatusActivityStyle","product":"core","slug":"tmux-window-setwindowstatusactivitystyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusActivityStyle","name":"SetWindowStatusActivityStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusActivityStyle stores the \"window-status-activity-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusActivityStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6902,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusActivityStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatusactivitystyle"},{"id":"tmux.Window.SetWindowStatusBellStyle","name":"SetWindowStatusBellStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusBellStyle stores the \"window-status-bell-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusBellStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6910,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStatusBellStyle","product":"core","slug":"tmux-window-setwindowstatusbellstyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusBellStyle","name":"SetWindowStatusBellStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusBellStyle stores the \"window-status-bell-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusBellStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6920,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusBellStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatusbellstyle"},{"id":"tmux.Window.SetWindowStatusCurrentFormat","name":"SetWindowStatusCurrentFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusCurrentFormat stores the \"window-status-current-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusCurrentFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6928,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStatusCurrentFormat","product":"core","slug":"tmux-window-setwindowstatuscurrentformat"},{"id":"tmux.GlobalWindowScope.SetWindowStatusCurrentFormat","name":"SetWindowStatusCurrentFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusCurrentFormat stores the \"window-status-current-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusCurrentFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6938,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusCurrentFormat","product":"core","slug":"tmux-globalwindowscope-setwindowstatuscurrentformat"},{"id":"tmux.Window.SetWindowStatusCurrentStyle","name":"SetWindowStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusCurrentStyle stores the \"window-status-current-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusCurrentStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6946,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStatusCurrentStyle","product":"core","slug":"tmux-window-setwindowstatuscurrentstyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusCurrentStyle","name":"SetWindowStatusCurrentStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusCurrentStyle stores the \"window-status-current-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusCurrentStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6956,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusCurrentStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatuscurrentstyle"},{"id":"tmux.Window.SetWindowStatusFormat","name":"SetWindowStatusFormat","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusFormat stores the \"window-status-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusFormat] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6964,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStatusFormat","product":"core","slug":"tmux-window-setwindowstatusformat"},{"id":"tmux.GlobalWindowScope.SetWindowStatusFormat","name":"SetWindowStatusFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusFormat stores the \"window-status-format\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusFormat] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6974,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusFormat","product":"core","slug":"tmux-globalwindowscope-setwindowstatusformat"},{"id":"tmux.Window.SetWindowStatusLastStyle","name":"SetWindowStatusLastStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusLastStyle stores the \"window-status-last-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusLastStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6982,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStatusLastStyle","product":"core","slug":"tmux-window-setwindowstatuslaststyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusLastStyle","name":"SetWindowStatusLastStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusLastStyle stores the \"window-status-last-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusLastStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":6992,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusLastStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatuslaststyle"},{"id":"tmux.Window.SetWindowStatusSeparator","name":"SetWindowStatusSeparator","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusSeparator stores the \"window-status-separator\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusSeparator] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7000,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStatusSeparator","product":"core","slug":"tmux-window-setwindowstatusseparator"},{"id":"tmux.GlobalWindowScope.SetWindowStatusSeparator","name":"SetWindowStatusSeparator","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusSeparator stores the \"window-status-separator\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusSeparator] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7010,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusSeparator","product":"core","slug":"tmux-globalwindowscope-setwindowstatusseparator"},{"id":"tmux.Window.SetWindowStatusStyle","name":"SetWindowStatusStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusStyle stores the \"window-status-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7018,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStatusStyle","product":"core","slug":"tmux-window-setwindowstatusstyle"},{"id":"tmux.GlobalWindowScope.SetWindowStatusStyle","name":"SetWindowStatusStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStatusStyle stores the \"window-status-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStatusStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7028,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStatusStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstatusstyle"},{"id":"tmux.Window.SetWindowStyle","name":"SetWindowStyle","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStyle stores the \"window-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStyle] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7036,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWindowStyle","product":"core","slug":"tmux-window-setwindowstyle"},{"id":"tmux.GlobalWindowScope.SetWindowStyle","name":"SetWindowStyle","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStyle stores the \"window-style\" window option as string (tmux 3.2a or later). Read it with [WindowOptionValues.WindowStyle] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7046,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWindowStyle","product":"core","slug":"tmux-globalwindowscope-setwindowstyle"},{"id":"tmux.Pane.SetWindowStyle","name":"SetWindowStyle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWindowStyle stores the \"window-style\" pane option as string (tmux 3.2a or later). Read it with [PaneOptionValues.WindowStyle] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7054,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetWindowStyle","product":"core","slug":"tmux-pane-setwindowstyle"},{"id":"tmux.Session.SetWordSeparators","name":"SetWordSeparators","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWordSeparators stores the \"word-separators\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.WordSeparators] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7064,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetWordSeparators","product":"core","slug":"tmux-session-setwordseparators"},{"id":"tmux.GlobalSessionScope.SetWordSeparators","name":"SetWordSeparators","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"string"}],"returns":"error"}],"doc":{"summary":"SetWordSeparators stores the \"word-separators\" session option as string (tmux 3.2a or later). Read it with [SessionOptionValues.WordSeparators] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7074,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetWordSeparators","product":"core","slug":"tmux-globalsessionscope-setwordseparators"},{"id":"tmux.Window.SetWrapSearch","name":"SetWrapSearch","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetWrapSearch stores the \"wrap-search\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.WrapSearch] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7082,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetWrapSearch","product":"core","slug":"tmux-window-setwrapsearch"},{"id":"tmux.GlobalWindowScope.SetWrapSearch","name":"SetWrapSearch","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetWrapSearch stores the \"wrap-search\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.WrapSearch] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7092,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetWrapSearch","product":"core","slug":"tmux-globalwindowscope-setwrapsearch"},{"id":"tmux.Window.SetXTermKeys","name":"SetXTermKeys","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetXTermKeys stores the \"xterm-keys\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.XTermKeys] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetXTermKeys","product":"core","slug":"tmux-window-setxtermkeys"},{"id":"tmux.GlobalWindowScope.SetXTermKeys","name":"SetXTermKeys","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"bool"}],"returns":"error"}],"doc":{"summary":"SetXTermKeys stores the \"xterm-keys\" window option as bool (tmux 3.2a or later). Read it with [WindowOptionValues.XTermKeys] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default."},"source":{"file":"tmux/option_generated.go","line":7110,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetXTermKeys","product":"core","slug":"tmux-globalwindowscope-setxtermkeys"},{"id":"tmux.Server.SetCodepointWidths","name":"SetCodepointWidths","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetCodepointWidths replaces the complete \"codepoint-widths\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.6 or later). Read it with [ServerOptionValues.CodepointWidths] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7119,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetCodepointWidths","product":"core","slug":"tmux-server-setcodepointwidths"},{"id":"tmux.Server.SetCommandAlias","name":"SetCommandAlias","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetCommandAlias replaces the complete \"command-alias\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [ServerOptionValues.CommandAlias] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7128,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetCommandAlias","product":"core","slug":"tmux-server-setcommandalias"},{"id":"tmux.Window.SetPaneColours","name":"SetPaneColours","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetPaneColours replaces the complete \"pane-colours\" window option array with SparseArray[string], preserving holes and empty values (tmux 3.3 or later). Read it with [WindowOptionValues.PaneColours] from [Window.Options]; [Window.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7137,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetPaneColours","product":"core","slug":"tmux-window-setpanecolours"},{"id":"tmux.GlobalWindowScope.SetPaneColours","name":"SetPaneColours","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetPaneColours replaces the complete \"pane-colours\" window option array with SparseArray[string], preserving holes and empty values (tmux 3.3 or later). Read it with [WindowOptionValues.PaneColours] from [GlobalWindowScope.Options]; [GlobalWindowScope.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7148,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetPaneColours","product":"core","slug":"tmux-globalwindowscope-setpanecolours"},{"id":"tmux.Pane.SetPaneColours","name":"SetPaneColours","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetPaneColours replaces the complete \"pane-colours\" pane option array with SparseArray[string], preserving holes and empty values (tmux 3.3 or later). Read it with [PaneOptionValues.PaneColours] from [Pane.Options]; [Pane.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7157,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetPaneColours","product":"core","slug":"tmux-pane-setpanecolours"},{"id":"tmux.Session.SetStatusFormat","name":"SetStatusFormat","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetStatusFormat replaces the complete \"status-format\" session option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [SessionOptionValues.StatusFormat] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7168,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetStatusFormat","product":"core","slug":"tmux-session-setstatusformat"},{"id":"tmux.GlobalSessionScope.SetStatusFormat","name":"SetStatusFormat","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetStatusFormat replaces the complete \"status-format\" session option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [SessionOptionValues.StatusFormat] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7179,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetStatusFormat","product":"core","slug":"tmux-globalsessionscope-setstatusformat"},{"id":"tmux.Server.SetTerminalFeatures","name":"SetTerminalFeatures","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetTerminalFeatures replaces the complete \"terminal-features\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [ServerOptionValues.TerminalFeatures] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7188,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetTerminalFeatures","product":"core","slug":"tmux-server-setterminalfeatures"},{"id":"tmux.Server.SetTerminalOverrides","name":"SetTerminalOverrides","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetTerminalOverrides replaces the complete \"terminal-overrides\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [ServerOptionValues.TerminalOverrides] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7197,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetTerminalOverrides","product":"core","slug":"tmux-server-setterminaloverrides"},{"id":"tmux.Session.SetUpdateEnvironment","name":"SetUpdateEnvironment","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetUpdateEnvironment replaces the complete \"update-environment\" session option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [SessionOptionValues.UpdateEnvironment] from [Session.Options]; [Session.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7206,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetUpdateEnvironment","product":"core","slug":"tmux-session-setupdateenvironment"},{"id":"tmux.GlobalSessionScope.SetUpdateEnvironment","name":"SetUpdateEnvironment","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetUpdateEnvironment replaces the complete \"update-environment\" session option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [SessionOptionValues.UpdateEnvironment] from [GlobalSessionScope.Options]; [GlobalSessionScope.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7217,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetUpdateEnvironment","product":"core","slug":"tmux-globalsessionscope-setupdateenvironment"},{"id":"tmux.Server.SetUserKeys","name":"SetUserKeys","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"value","type":"SparseArray[string]"}],"returns":"(SetArrayResult, error)"}],"doc":{"summary":"SetUserKeys replaces the complete \"user-keys\" server option array with SparseArray[string], preserving holes and empty values (tmux 3.2a or later). Read it with [ServerOptionValues.UserKeys] from [Server.Options]; [Server.UnsetOption] restores inheritance or the global default. Replacement is not atomic: the result reports confirmed writes, and failures stop without rollback. Serialize concurrent replacement of the same target and option."},"source":{"file":"tmux/option_generated.go","line":7226,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetUserKeys","product":"core","slug":"tmux-server-setuserkeys"},{"id":"tmux.SetOptionOptions","name":"SetOptionOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetOptionOptions controls set-option mutation flags. Its zero value sends no optional mutation flags."},"source":{"file":"tmux/option_mutation.go","line":7,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetOptionOptions","product":"core","slug":"tmux-setoptionoptions"},{"id":"tmux.SetOptionOptions.ExpandFormat","name":"ExpandFormat","kind":"attribute","modifiers":[],"parent":"tmux.SetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"ExpandFormat expands tmux formats in the value before storing it."},"source":{"file":"tmux/option_mutation.go","line":9,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetOptionOptions.ExpandFormat","product":"core","slug":"tmux-setoptionoptions-expandformat"},{"id":"tmux.SetOptionOptions.PreventOverwrite","name":"PreventOverwrite","kind":"attribute","modifiers":[],"parent":"tmux.SetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"PreventOverwrite leaves an existing option unchanged."},"source":{"file":"tmux/option_mutation.go","line":11,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetOptionOptions.PreventOverwrite","product":"core","slug":"tmux-setoptionoptions-preventoverwrite"},{"id":"tmux.SetOptionOptions.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.SetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux's missing-option diagnostic."},"source":{"file":"tmux/option_mutation.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetOptionOptions.Quiet","product":"core","slug":"tmux-setoptionoptions-quiet"},{"id":"tmux.UnsetOptionOptions","name":"UnsetOptionOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"UnsetOptionOptions controls set-option unset behavior. Its zero value unsets only the selected option."},"source":{"file":"tmux/option_mutation.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnsetOptionOptions","product":"core","slug":"tmux-unsetoptionoptions"},{"id":"tmux.UnsetOptionOptions.UnsetPanes","name":"UnsetPanes","kind":"attribute","modifiers":[],"parent":"tmux.UnsetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"UnsetPanes unsets a window option on every pane in a Window receiver."},"source":{"file":"tmux/option_mutation.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnsetOptionOptions.UnsetPanes","product":"core","slug":"tmux-unsetoptionoptions-unsetpanes"},{"id":"tmux.UnsetOptionOptions.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.UnsetOptionOptions","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux's missing-option diagnostic."},"source":{"file":"tmux/option_mutation.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnsetOptionOptions.Quiet","product":"core","slug":"tmux-unsetoptionoptions-quiet"},{"id":"tmux.Server.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a server-scope option without refreshing existing models. It may validate a known option against the live version. Completed failures return secret-safe option errors; cancellation does not prove the mutation was not accepted by tmux."},"source":{"file":"tmux/option_mutation.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetOption","product":"core","slug":"tmux-server-setoption"},{"id":"tmux.GlobalSessionScope.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a global session option without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.SetOption","product":"core","slug":"tmux-globalsessionscope-setoption"},{"id":"tmux.GlobalWindowScope.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a global window option without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.SetOption","product":"core","slug":"tmux-globalwindowscope-setoption"},{"id":"tmux.Session.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a session option at this stable session target without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":92,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SetOption","product":"core","slug":"tmux-session-setoption"},{"id":"tmux.Window.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a window option at this exact window target without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SetOption","product":"core","slug":"tmux-window-setoption"},{"id":"tmux.Pane.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"SetOption stores a pane option at this exact pane target without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove tmux did not accept the mutation."},"source":{"file":"tmux/option_mutation.go","line":128,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetOption","product":"core","slug":"tmux-pane-setoption"},{"id":"tmux.Server.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a server-scope option without refreshing existing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.AppendOption","product":"core","slug":"tmux-server-appendoption"},{"id":"tmux.GlobalSessionScope.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a global session option without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":165,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.AppendOption","product":"core","slug":"tmux-globalsessionscope-appendoption"},{"id":"tmux.GlobalWindowScope.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a global window option without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":186,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.AppendOption","product":"core","slug":"tmux-globalwindowscope-appendoption"},{"id":"tmux.Session.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a session option at this stable session target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":207,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.AppendOption","product":"core","slug":"tmux-session-appendoption"},{"id":"tmux.Window.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a window option at this exact window target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":223,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.AppendOption","product":"core","slug":"tmux-window-appendoption"},{"id":"tmux.Pane.AppendOption","name":"AppendOption","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"value","type":"string"},{"name":"options","type":"SetOptionOptions"}],"returns":"error"}],"doc":{"summary":"AppendOption appends to a pane option at this exact pane target without refreshing models. Completed failures are secret-safe option errors; cancellation does not prove the append was not accepted."},"source":{"file":"tmux/option_mutation.go","line":243,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.AppendOption","product":"core","slug":"tmux-pane-appendoption"},{"id":"tmux.Server.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a server-scope option without refreshing existing models. UnsetPanes is invalid at server scope. Completed failures are secret-safe option errors; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":259,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.UnsetOption","product":"core","slug":"tmux-server-unsetoption"},{"id":"tmux.GlobalSessionScope.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a global session option without refreshing models. UnsetPanes is invalid at this scope; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":273,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.UnsetOption","product":"core","slug":"tmux-globalsessionscope-unsetoption"},{"id":"tmux.GlobalWindowScope.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a global window option without refreshing models. UnsetPanes is invalid at this scope; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":295,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.UnsetOption","product":"core","slug":"tmux-globalwindowscope-unsetoption"},{"id":"tmux.Session.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a session option at this stable session target without refreshing models. UnsetPanes is invalid at this scope; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":317,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.UnsetOption","product":"core","slug":"tmux-session-unsetoption"},{"id":"tmux.Window.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a window option at this exact window target, or its pane copies with UnsetPanes, without refreshing models. Cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":335,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.UnsetOption","product":"core","slug":"tmux-window-unsetoption"},{"id":"tmux.Pane.UnsetOption","name":"UnsetOption","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"},{"name":"options","type":"UnsetOptionOptions"}],"returns":"error"}],"doc":{"summary":"UnsetOption unsets a pane option at this exact pane target without refreshing models. UnsetPanes is invalid at this scope; cancellation does not prove the unset was not accepted."},"source":{"file":"tmux/option_mutation.go","line":358,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.UnsetOption","product":"core","slug":"tmux-pane-unsetoption"},{"id":"tmux.Server.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(ServerOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known server options, including inherited values. A read or transport failure is returned rather than answered with zero values; context errors propagate. Each returned accessor names the setter that writes it, so [ServerOptionValues.BufferLimit] pairs with [Server.SetBufferLimit]."},"source":{"file":"tmux/option_read.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Options","product":"core","slug":"tmux-server-options"},{"id":"tmux.GlobalSessionScope.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(SessionOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known global session options, including defaults. A read failure is returned rather than answered with zero values; context errors propagate. Each returned accessor names the setter that writes it, so [SessionOptionValues.Status] pairs with [GlobalSessionScope.SetStatus]."},"source":{"file":"tmux/option_read.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.Options","product":"core","slug":"tmux-globalsessionscope-options"},{"id":"tmux.GlobalWindowScope.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(WindowOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known global window options, including defaults. A read failure is returned rather than answered with zero values; context errors propagate. Each returned accessor names the setter that writes it, so [WindowOptionValues.MainPaneWidth] pairs with [GlobalWindowScope.SetMainPaneWidth]."},"source":{"file":"tmux/option_read.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.Options","product":"core","slug":"tmux-globalwindowscope-options"},{"id":"tmux.Session.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(SessionOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known options at this stable session target, including inherited values. A read failure is returned rather than answered with zero values; context errors propagate. Each returned accessor names the setter that writes it, so [SessionOptionValues.Mouse] pairs with [Session.SetMouse]."},"source":{"file":"tmux/option_read.go","line":75,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Options","product":"core","slug":"tmux-session-options"},{"id":"tmux.Window.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(WindowOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known options at this exact window target, including inherited values. The receiver's exact linked session context controls tmux format evaluation. A read failure is returned rather than answered with zero values. Each returned accessor names the setter that writes it, so [WindowOptionValues.MainPaneWidth] pairs with [Window.SetMainPaneWidth]."},"source":{"file":"tmux/option_read.go","line":100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Options","product":"core","slug":"tmux-window-options"},{"id":"tmux.Pane.Options","name":"Options","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(PaneOptionValues, error)"}],"doc":{"summary":"Options returns a freshly decoded, caller-owned view of known options at this exact pane target, including inherited values. The receiver's exact linked session context controls tmux format evaluation. A read failure is returned rather than answered with zero values. Each returned accessor names the setter that writes it, so [PaneOptionValues.WindowStyle] pairs with [Pane.SetWindowStyle]."},"source":{"file":"tmux/option_read.go","line":125,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Options","product":"core","slug":"tmux-pane-options"},{"id":"tmux.Server.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact server-scope option value. A successful string is caller-owned; ok reports presence. Targeted reads do not use list leniency, and completed failures return a secret-safe option error. An unindexed empty array is indistinguishable from an empty scalar; use Options for typed array presence."},"source":{"file":"tmux/option_read.go","line":149,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.RawOption","product":"core","slug":"tmux-server-rawoption"},{"id":"tmux.GlobalSessionScope.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.GlobalSessionScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact global session-option value. A successful string is caller-owned, and ok reports presence. An unindexed empty array is indistinguishable from an empty scalar; use Options for typed array presence."},"source":{"file":"tmux/option_read.go","line":157,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope.RawOption","product":"core","slug":"tmux-globalsessionscope-rawoption"},{"id":"tmux.GlobalWindowScope.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.GlobalWindowScope","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact global window-option value. A successful string is caller-owned, and ok reports presence. An unindexed empty array is indistinguishable from an empty scalar; use Options for typed array presence."},"source":{"file":"tmux/option_read.go","line":168,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope.RawOption","product":"core","slug":"tmux-globalwindowscope-rawoption"},{"id":"tmux.Session.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact session option value at this stable session target. A successful string is caller-owned; ok reports presence, and a completed failure is returned rather than normalized. An unindexed empty array is indistinguishable from an empty scalar; use Options for typed array presence."},"source":{"file":"tmux/option_read.go","line":180,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.RawOption","product":"core","slug":"tmux-session-rawoption"},{"id":"tmux.Window.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact window option value at this exact window target. A successful string is caller-owned; the receiver's exact linked session context controls tmux format evaluation, and a completed failure is returned."},"source":{"file":"tmux/option_read.go","line":191,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.RawOption","product":"core","slug":"tmux-window-rawoption"},{"id":"tmux.Pane.RawOption","name":"RawOption","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(string, bool, error)"}],"doc":{"summary":"RawOption returns one exact pane option value at this exact pane target. A successful string is caller-owned; the receiver's exact linked session context controls tmux format evaluation, and a completed failure is returned."},"source":{"file":"tmux/option_read.go","line":202,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.RawOption","product":"core","slug":"tmux-pane-rawoption"},{"id":"tmux.SetArrayResult","name":"SetArrayResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetArrayResult reports confirmed progress from a typed sparse-array replacement. AppliedIndices is caller-owned and is non-nil whenever mutation was attempted."},"source":{"file":"tmux/option_runtime.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetArrayResult","product":"core","slug":"tmux-setarrayresult"},{"id":"tmux.SetArrayResult.Replaced","name":"Replaced","kind":"attribute","modifiers":[],"parent":"tmux.SetArrayResult","signatures":[],"type":"bool","doc":{"summary":"Replaced reports whether tmux confirmed the base replacement."},"source":{"file":"tmux/option_runtime.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetArrayResult.Replaced","product":"core","slug":"tmux-setarrayresult-replaced"},{"id":"tmux.SetArrayResult.AppliedIndices","name":"AppliedIndices","kind":"attribute","modifiers":[],"parent":"tmux.SetArrayResult","signatures":[],"type":"[]int","doc":{"summary":"AppliedIndices lists confirmed indexed writes in ascending order."},"source":{"file":"tmux/option_runtime.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetArrayResult.AppliedIndices","product":"core","slug":"tmux-setarrayresult-appliedindices"},{"id":"tmux.GlobalSessionScope","name":"GlobalSessionScope","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"GlobalSessionScope is an immutable handle for global session options and hooks. Its zero value is invalid because it contains a zero [Server]."},"source":{"file":"tmux/option_scope.go","line":5,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalSessionScope","product":"core","slug":"tmux-globalsessionscope"},{"id":"tmux.GlobalWindowScope","name":"GlobalWindowScope","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"GlobalWindowScope is an immutable handle for global window options and hooks. Its zero value is invalid because it contains a zero [Server]."},"source":{"file":"tmux/option_scope.go","line":11,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.GlobalWindowScope","product":"core","slug":"tmux-globalwindowscope"},{"id":"tmux.Server.GlobalSessionScope","name":"GlobalSessionScope","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"GlobalSessionScope"}],"doc":{"summary":"GlobalSessionScope returns a handle that preserves s and its error policy."},"source":{"file":"tmux/option_scope.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.GlobalSessionScope","product":"core","slug":"tmux-server-globalsessionscope"},{"id":"tmux.Server.GlobalWindowScope","name":"GlobalWindowScope","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"GlobalWindowScope"}],"doc":{"summary":"GlobalWindowScope returns a handle that preserves s and its error policy."},"source":{"file":"tmux/option_scope.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.GlobalWindowScope","product":"core","slug":"tmux-server-globalwindowscope"},{"id":"tmux.OptionOrigin","name":"OptionOrigin","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionOrigin identifies where a present option value was resolved. The declared values form the complete set of valid origins."},"source":{"file":"tmux/option_value.go","line":7,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionOrigin","product":"core","slug":"tmux-optionorigin"},{"id":"tmux.OptionOrigin.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.OptionOrigin","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the origin's tmux vocabulary, so an origin prints as a word beside the generated option values, which all carry String."},"source":{"file":"tmux/option_value.go","line":11,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionOrigin.String","product":"core","slug":"tmux-optionorigin-string"},{"id":"tmux.OptionOriginLocal","name":"OptionOriginLocal","kind":"constant","modifiers":[],"signatures":[],"type":"OptionOrigin","doc":{"summary":"OptionOriginLocal identifies a value set directly at the queried scope."},"source":{"file":"tmux/option_value.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionOriginLocal","product":"core","slug":"tmux-optionoriginlocal"},{"id":"tmux.OptionOriginInherited","name":"OptionOriginInherited","kind":"constant","modifiers":[],"signatures":[],"type":"OptionOrigin","doc":{"summary":"OptionOriginInherited identifies a value inherited from a parent scope."},"source":{"file":"tmux/option_value.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionOriginInherited","product":"core","slug":"tmux-optionorigininherited"},{"id":"tmux.OptionValue","name":"OptionValue","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OptionValue preserves option presence and resolution origin. Its zero value is absent. Copies of reference-bearing T values are shallow."},"source":{"file":"tmux/option_value.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionValue","product":"core","slug":"tmux-optionvalue"},{"id":"tmux.OptionValue.Get","name":"Get","kind":"method","modifiers":[],"parent":"tmux.OptionValue","signatures":[{"params":[],"returns":"(T, bool)"}],"doc":{"summary":"Get returns the option value and reports whether it is present."},"source":{"file":"tmux/option_value.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionValue.Get","product":"core","slug":"tmux-optionvalue-get"},{"id":"tmux.OptionValue.Origin","name":"Origin","kind":"method","modifiers":[],"parent":"tmux.OptionValue","signatures":[{"params":[],"returns":"(OptionOrigin, bool)"}],"doc":{"summary":"Origin returns the resolution origin and reports whether the option is present."},"source":{"file":"tmux/option_value.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OptionValue.Origin","product":"core","slug":"tmux-optionvalue-origin"},{"id":"tmux.ErrInvalidCaptureRequest","name":"ErrInvalidCaptureRequest","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidCaptureRequest identifies a capture request that cannot be represented safely as tmux arguments."},"source":{"file":"tmux/pane_capture.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidCaptureRequest","product":"core","slug":"tmux-errinvalidcapturerequest"},{"id":"tmux.CaptureRequestError","name":"CaptureRequestError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CaptureRequestError reports a [CapturePaneRequest] field that cannot be represented as a tmux capture-pane argument. It matches [ErrInvalidCaptureRequest] through [errors.Is] and is available through [errors.As]."},"source":{"file":"tmux/pane_capture.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CaptureRequestError","product":"core","slug":"tmux-capturerequesterror"},{"id":"tmux.CaptureRequestError.Field","name":"Field","kind":"attribute","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[],"type":"string","doc":{"summary":"Field names the invalid request field."},"source":{"file":"tmux/pane_capture.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CaptureRequestError.Field","product":"core","slug":"tmux-capturerequesterror-field"},{"id":"tmux.CaptureRequestError.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[],"type":"string","doc":{"summary":"Value is the rejected field value. It may be empty when absence is the error."},"source":{"file":"tmux/pane_capture.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CaptureRequestError.Value","product":"core","slug":"tmux-capturerequesterror-value"},{"id":"tmux.CaptureRequestError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[],"type":"string","doc":{"summary":"Reason describes the violated request constraint without promising a stable complete error string."},"source":{"file":"tmux/pane_capture.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CaptureRequestError.Reason","product":"core","slug":"tmux-capturerequesterror-reason"},{"id":"tmux.CaptureRequestError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/pane_capture.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CaptureRequestError.Error","product":"core","slug":"tmux-capturerequesterror-error"},{"id":"tmux.CaptureRequestError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.CaptureRequestError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes CaptureRequestError compatible with ErrInvalidCaptureRequest."},"source":{"file":"tmux/pane_capture.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CaptureRequestError.Unwrap","product":"core","slug":"tmux-capturerequesterror-unwrap"},{"id":"tmux.CapturePosition","name":"CapturePosition","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CapturePosition selects a line relative to tmux's visible pane or history. Its zero value omits the boundary and lets tmux use the visible-screen default. Construct numeric positions with [CaptureLine]."},"source":{"file":"tmux/pane_capture.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePosition","product":"core","slug":"tmux-captureposition"},{"id":"tmux.CaptureBoundary","name":"CaptureBoundary","kind":"constant","modifiers":[],"signatures":[],"type":"CapturePosition","doc":{"summary":"CaptureBoundary selects the start of history when used as Start and the end of the visible pane when used as End."},"source":{"file":"tmux/pane_capture.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CaptureBoundary","product":"core","slug":"tmux-captureboundary"},{"id":"tmux.CaptureLine","name":"CaptureLine","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"line","type":"int"}],"returns":"CapturePosition"}],"doc":{"summary":"CaptureLine returns the canonical tmux representation of a capture line. Zero is the first visible line; negative values address history."},"source":{"file":"tmux/pane_capture.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CaptureLine","product":"core","slug":"tmux-captureline"},{"id":"tmux.CapturePaneRequest","name":"CapturePaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CapturePaneRequest configures pane capture. Its zero value captures the visible screen with tmux's default text handling. Version-gated flags follow [UnsupportedPolicy]. [CaptureBoundary] selects the start of history for Start and the end of the visible pane for End."},"source":{"file":"tmux/pane_capture.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest","product":"core","slug":"tmux-capturepanerequest"},{"id":"tmux.CapturePaneRequest.Start","name":"Start","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"CapturePosition","doc":{"summary":"Start selects the first captured line. Empty uses tmux's visible-screen default; CaptureBoundary selects the start of history."},"source":{"file":"tmux/pane_capture.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.Start","product":"core","slug":"tmux-capturepanerequest-start"},{"id":"tmux.CapturePaneRequest.End","name":"End","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"CapturePosition","doc":{"summary":"End selects the last captured line. Empty uses tmux's visible-screen default; CaptureBoundary selects the end of the visible pane."},"source":{"file":"tmux/pane_capture.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.End","product":"core","slug":"tmux-capturepanerequest-end"},{"id":"tmux.CapturePaneRequest.EscapeSequences","name":"EscapeSequences","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"EscapeSequences includes terminal attribute escape sequences."},"source":{"file":"tmux/pane_capture.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.EscapeSequences","product":"core","slug":"tmux-capturepanerequest-escapesequences"},{"id":"tmux.CapturePaneRequest.EscapeNonPrintable","name":"EscapeNonPrintable","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"EscapeNonPrintable renders non-printable characters as octal escapes."},"source":{"file":"tmux/pane_capture.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.EscapeNonPrintable","product":"core","slug":"tmux-capturepanerequest-escapenonprintable"},{"id":"tmux.CapturePaneRequest.JoinWrapped","name":"JoinWrapped","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"JoinWrapped joins wrapped lines, preserves their trailing spaces, and implies tmux trimming independently of TrimTrailing."},"source":{"file":"tmux/pane_capture.go","line":85,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.JoinWrapped","product":"core","slug":"tmux-capturepanerequest-joinwrapped"},{"id":"tmux.CapturePaneRequest.PreserveTrailing","name":"PreserveTrailing","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"PreserveTrailing preserves trailing spaces at each line end."},"source":{"file":"tmux/pane_capture.go","line":87,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.PreserveTrailing","product":"core","slug":"tmux-capturepanerequest-preservetrailing"},{"id":"tmux.CapturePaneRequest.TrimTrailing","name":"TrimTrailing","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"TrimTrailing omits trailing positions without characters. It requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.TrimTrailing","product":"core","slug":"tmux-capturepanerequest-trimtrailing"},{"id":"tmux.CapturePaneRequest.AlternateScreen","name":"AlternateScreen","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"AlternateScreen captures the alternate screen without history."},"source":{"file":"tmux/pane_capture.go","line":92,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.AlternateScreen","product":"core","slug":"tmux-capturepanerequest-alternatescreen"},{"id":"tmux.CapturePaneRequest.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux's error when AlternateScreen is requested but no alternate screen exists."},"source":{"file":"tmux/pane_capture.go","line":95,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.Quiet","product":"core","slug":"tmux-capturepanerequest-quiet"},{"id":"tmux.CapturePaneRequest.ModeScreen","name":"ModeScreen","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"ModeScreen captures the active mode screen. It requires tmux 3.6; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":98,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.ModeScreen","product":"core","slug":"tmux-capturepanerequest-modescreen"},{"id":"tmux.CapturePaneRequest.Pending","name":"Pending","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Pending captures only the beginning of an incomplete escape sequence."},"source":{"file":"tmux/pane_capture.go","line":100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.Pending","product":"core","slug":"tmux-capturepanerequest-pending"},{"id":"tmux.CapturePaneRequest.Hyperlinks","name":"Hyperlinks","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Hyperlinks captures hyperlink metadata for the selected lines. It requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":103,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.Hyperlinks","product":"core","slug":"tmux-capturepanerequest-hyperlinks"},{"id":"tmux.CapturePaneRequest.LineNumbers","name":"LineNumbers","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"LineNumbers prefixes each line with its tmux line number. It requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.LineNumbers","product":"core","slug":"tmux-capturepanerequest-linenumbers"},{"id":"tmux.CapturePaneRequest.LineFlags","name":"LineFlags","kind":"attribute","modifiers":[],"parent":"tmux.CapturePaneRequest","signatures":[],"type":"bool","doc":{"summary":"LineFlags prefixes each line with tmux line metadata flags. It requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/pane_capture.go","line":109,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CapturePaneRequest.LineFlags","product":"core","slug":"tmux-capturepanerequest-lineflags"},{"id":"tmux.Pane.Capture","name":"Capture","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"CapturePaneRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"Capture captures printed content from the receiver's exact linked pane. It returns a caller-owned slice. A completed nonzero exit or stderr becomes a [CommandError]; any stdout tmux still printed is returned alongside it.","body":"This is a point-in-time capture rather than a stream; the zero request reads\nthe visible screen. It may include a shell's echo of [Pane.SendKeys] input.\nCompare whole lines when polling; use [ControlClient.NextNotification] or\n[Server.WaitFor] when the application exposes a stream or explicit signal.\n\nInvalid positions fail before execution. Transport and context failures return\nany partial stdout with the error."},"source":{"file":"tmux/pane_capture.go","line":123,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Capture","product":"core","slug":"tmux-pane-capture"},{"id":"tmux.Pane.CaptureBytes","name":"CaptureBytes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"CapturePaneRequest"}],"returns":"([]byte, error)"}],"doc":{"summary":"CaptureBytes captures printed content from the receiver's exact linked pane as caller-owned stdout bytes. It preserves tmux's output delimiters and trailing newlines after tmux has interpreted the pane's terminal contents.","body":"Its validation and failure behavior match [Pane.Capture], including returning\npartial bytes with transport or context errors."},"source":{"file":"tmux/pane_capture.go","line":137,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CaptureBytes","product":"core","slug":"tmux-pane-capturebytes"},{"id":"tmux.Pane.CaptureToBuffer","name":"CaptureToBuffer","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"buffer","type":"string"},{"name":"request","type":"CapturePaneRequest"}],"returns":"error"}],"doc":{"summary":"CaptureToBuffer captures content from the receiver's exact linked pane into the nonempty named tmux buffer. The buffer is owned by tmux and no printed output is returned. A completed nonzero exit or stderr becomes a [CommandError].","body":"Invalid requests fail before execution. Transport and context errors are\ndelivery-ambiguous: the buffer may already have changed."},"source":{"file":"tmux/pane_capture.go","line":152,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CaptureToBuffer","product":"core","slug":"tmux-pane-capturetobuffer"},{"id":"tmux.Pane.CaptureToFile","name":"CaptureToFile","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"path","type":"string"},{"name":"request","type":"CapturePaneRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"CaptureToFile captures the receiver's exact linked pane through a tmux buffer and the file at path, returning the same lines [Pane.Capture] returns.","body":"Printed captures cannot safely cross a control connection, so [Pane.Capture]\nand [Pane.CaptureBytes] use a subprocess or reject a connection. CaptureToFile\nstages through a scratch buffer so capture, save, and cleanup can all use the\nconnection's command lanes.\n\npath must name a file the tmux server can write and this process can read.\nIt is replaced and left for the caller. Concurrent calls must use distinct\npaths. The scratch tmux buffer is deleted before return when possible.\n\nValidation and version gating match [Pane.Capture]. Capture, save, and\nfile-read failures return an error with no lines; buffer cleanup is best effort."},"source":{"file":"tmux/pane_capture.go","line":180,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CaptureToFile","product":"core","slug":"tmux-pane-capturetofile"},{"id":"tmux.Pane.CaptureTo","name":"CaptureTo","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"destination","type":"io.Writer"},{"name":"request","type":"CapturePaneRequest"}],"returns":"error"}],"doc":{"summary":"CaptureTo streams printed content from the receiver's exact linked pane into destination without holding a screen in memory, which is what makes a long scrollback affordable to write straight to a file or a compressor. Like [Pane.Capture] it reads the screen at one point in time rather than following it; the zero request reads the visible screen and version-gated fields follow [UnsupportedPolicy].","body":"A completed nonzero exit becomes a redacted command error, because CaptureTo\nreturns no bytes for the caller to inspect. Cancellation does not prove\ndestination received the complete screen, and a copy failure takes\nprecedence over a completed command's exit status because it means\ndestination never saw everything tmux sent. Printed captures always use a\nsubprocess, so a [Connection]-bound Pane returns\n[ErrConnectionRequiresProcess]; [Pane.CaptureToFile] stages through a tmux\nbuffer and runs over a connection."},"source":{"file":"tmux/pane_capture.go","line":388,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CaptureTo","product":"core","slug":"tmux-pane-captureto"},{"id":"tmux.NewPaneRequest","name":"NewPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NewPaneRequest configures a floating pane and requires tmux 3.7 or later. Its zero value creates a detached floating pane with tmux's default size, position, styles, and command. Nil pointer fields omit their options; nonnil pointers are explicit, including empty style or message strings. Width and Height must be nonnegative. Empty and Command are mutually exclusive. Unsupported tmux versions return [VersionTooLowError] rather than omitting fields.","body":"Methods copy pointers and Environment before I/O; concurrent mutation during\nthe copy is unsafe."},"source":{"file":"tmux/pane_create.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest","product":"core","slug":"tmux-newpanerequest"},{"id":"tmux.NewPaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets the created pane become active in the exact target winlink; false preserves its active pane."},"source":{"file":"tmux/pane_create.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Attach","product":"core","slug":"tmux-newpanerequest-attach"},{"id":"tmux.NewPaneRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Named-user forms such as ~other are rejected; empty inherits tmux's default."},"source":{"file":"tmux/pane_create.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.StartDirectory","product":"core","slug":"tmux-newpanerequest-startdirectory"},{"id":"tmux.NewPaneRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"string","doc":{"summary":"Command starts the pane with this shell command; empty uses tmux's default."},"source":{"file":"tmux/pane_create.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Command","product":"core","slug":"tmux-newpanerequest-command"},{"id":"tmux.NewPaneRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order. The map is not retained; nil and an empty map both add no entries."},"source":{"file":"tmux/pane_create.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Environment","product":"core","slug":"tmux-newpanerequest-environment"},{"id":"tmux.NewPaneRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Width sets a nonnegative pane width; nil lets tmux choose."},"source":{"file":"tmux/pane_create.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Width","product":"core","slug":"tmux-newpanerequest-width"},{"id":"tmux.NewPaneRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Height sets a nonnegative pane height; nil lets tmux choose."},"source":{"file":"tmux/pane_create.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Height","product":"core","slug":"tmux-newpanerequest-height"},{"id":"tmux.NewPaneRequest.X","name":"X","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*int","doc":{"summary":"X sets the horizontal position; nil lets tmux choose."},"source":{"file":"tmux/pane_create.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.X","product":"core","slug":"tmux-newpanerequest-x"},{"id":"tmux.NewPaneRequest.Y","name":"Y","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Y sets the vertical position; nil lets tmux choose."},"source":{"file":"tmux/pane_create.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Y","product":"core","slug":"tmux-newpanerequest-y"},{"id":"tmux.NewPaneRequest.Zoom","name":"Zoom","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Zoom preserves the target window's zoomed state."},"source":{"file":"tmux/pane_create.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Zoom","product":"core","slug":"tmux-newpanerequest-zoom"},{"id":"tmux.NewPaneRequest.Empty","name":"Empty","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Empty creates a pane without starting a command."},"source":{"file":"tmux/pane_create.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Empty","product":"core","slug":"tmux-newpanerequest-empty"},{"id":"tmux.NewPaneRequest.Style","name":"Style","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*string","doc":{"summary":"Style sets the pane style; nil omits it."},"source":{"file":"tmux/pane_create.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Style","product":"core","slug":"tmux-newpanerequest-style"},{"id":"tmux.NewPaneRequest.ActiveBorderStyle","name":"ActiveBorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*string","doc":{"summary":"ActiveBorderStyle sets the active border style; nil omits it."},"source":{"file":"tmux/pane_create.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.ActiveBorderStyle","product":"core","slug":"tmux-newpanerequest-activeborderstyle"},{"id":"tmux.NewPaneRequest.InactiveBorderStyle","name":"InactiveBorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*string","doc":{"summary":"InactiveBorderStyle sets the inactive border style; nil omits it."},"source":{"file":"tmux/pane_create.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.InactiveBorderStyle","product":"core","slug":"tmux-newpanerequest-inactiveborderstyle"},{"id":"tmux.NewPaneRequest.Message","name":"Message","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"*string","doc":{"summary":"Message sets the pane message; nil omits it."},"source":{"file":"tmux/pane_create.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Message","product":"core","slug":"tmux-newpanerequest-message"},{"id":"tmux.NewPaneRequest.Keep","name":"Keep","kind":"attribute","modifiers":[],"parent":"tmux.NewPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Keep preserves the pane after its command exits."},"source":{"file":"tmux/pane_create.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPaneRequest.Keep","product":"core","slug":"tmux-newpanerequest-keep"},{"id":"tmux.SplitPaneRequest","name":"SplitPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SplitPaneRequest configures tiled pane creation on tmux 3.2a or later. Its zero value creates a detached pane below the exact target with tmux's default size and command. Nil pointer fields omit their options; nonnil pointers are explicit, including empty style or message strings. Size and Percentage are mutually exclusive. Invalid values are rejected before tmux is mutated.","body":"Methods copy pointer and map values before I/O; concurrent mutation is unsafe.\nEmpty, styles, Message, and Keep require tmux 3.7 and follow\n[UnsupportedPolicy]. Empty and Command conflict only when Empty is supported."},"source":{"file":"tmux/pane_create.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest","product":"core","slug":"tmux-splitpanerequest"},{"id":"tmux.SplitPaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets the created pane become active in the exact target winlink; false preserves its active pane."},"source":{"file":"tmux/pane_create.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Attach","product":"core","slug":"tmux-splitpanerequest-attach"},{"id":"tmux.SplitPaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"PaneDirection","doc":{"summary":"Direction selects the side of the target; zero means below."},"source":{"file":"tmux/pane_create.go","line":72,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Direction","product":"core","slug":"tmux-splitpanerequest-direction"},{"id":"tmux.SplitPaneRequest.Size","name":"Size","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Size selects a nonnegative absolute pane size; nil omits it."},"source":{"file":"tmux/pane_create.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Size","product":"core","slug":"tmux-splitpanerequest-size"},{"id":"tmux.SplitPaneRequest.Percentage","name":"Percentage","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Percentage selects a size from 0 through 100; nil omits it. It is sent as tmux's \"-l N%\", which every supported version accepts; the older -p spelling is rejected by tmux 3.4."},"source":{"file":"tmux/pane_create.go","line":78,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Percentage","product":"core","slug":"tmux-splitpanerequest-percentage"},{"id":"tmux.SplitPaneRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Named-user forms such as ~other are rejected; empty inherits tmux's default."},"source":{"file":"tmux/pane_create.go","line":81,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.StartDirectory","product":"core","slug":"tmux-splitpanerequest-startdirectory"},{"id":"tmux.SplitPaneRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"string","doc":{"summary":"Command starts the pane with this shell command; empty uses tmux's default."},"source":{"file":"tmux/pane_create.go","line":83,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Command","product":"core","slug":"tmux-splitpanerequest-command"},{"id":"tmux.SplitPaneRequest.FullWindow","name":"FullWindow","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"FullWindow lets the new pane span the full window size."},"source":{"file":"tmux/pane_create.go","line":85,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.FullWindow","product":"core","slug":"tmux-splitpanerequest-fullwindow"},{"id":"tmux.SplitPaneRequest.Zoom","name":"Zoom","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Zoom preserves the window's zoomed state after the split."},"source":{"file":"tmux/pane_create.go","line":87,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Zoom","product":"core","slug":"tmux-splitpanerequest-zoom"},{"id":"tmux.SplitPaneRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order and is not retained; nil and an empty map both add no entries."},"source":{"file":"tmux/pane_create.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Environment","product":"core","slug":"tmux-splitpanerequest-environment"},{"id":"tmux.SplitPaneRequest.Empty","name":"Empty","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Empty requests an empty pane on tmux 3.7 or later."},"source":{"file":"tmux/pane_create.go","line":92,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Empty","product":"core","slug":"tmux-splitpanerequest-empty"},{"id":"tmux.SplitPaneRequest.Style","name":"Style","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*string","doc":{"summary":"Style sets the pane style on tmux 3.7 or later; nil omits it."},"source":{"file":"tmux/pane_create.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Style","product":"core","slug":"tmux-splitpanerequest-style"},{"id":"tmux.SplitPaneRequest.ActiveBorderStyle","name":"ActiveBorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*string","doc":{"summary":"ActiveBorderStyle sets the active border style on tmux 3.7 or later; nil omits it."},"source":{"file":"tmux/pane_create.go","line":97,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.ActiveBorderStyle","product":"core","slug":"tmux-splitpanerequest-activeborderstyle"},{"id":"tmux.SplitPaneRequest.InactiveBorderStyle","name":"InactiveBorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*string","doc":{"summary":"InactiveBorderStyle sets the inactive border style on tmux 3.7 or later; nil omits it."},"source":{"file":"tmux/pane_create.go","line":100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.InactiveBorderStyle","product":"core","slug":"tmux-splitpanerequest-inactiveborderstyle"},{"id":"tmux.SplitPaneRequest.Message","name":"Message","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"*string","doc":{"summary":"Message sets the pane message on tmux 3.7 or later; nil omits it."},"source":{"file":"tmux/pane_create.go","line":102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Message","product":"core","slug":"tmux-splitpanerequest-message"},{"id":"tmux.SplitPaneRequest.Keep","name":"Keep","kind":"attribute","modifiers":[],"parent":"tmux.SplitPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Keep preserves the pane after its command exits on tmux 3.7 or later."},"source":{"file":"tmux/pane_create.go","line":104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SplitPaneRequest.Keep","product":"core","slug":"tmux-splitpanerequest-keep"},{"id":"tmux.Window.NewPane","name":"NewPane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"NewPane creates a floating pane in the receiver's exact winlink. Attach makes the new pane active in that session and winlink; it is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the receiver SessionID and WindowID rather than by canonical ID-only refresh.","body":"If tmux reports a [PaneID] before a transport or refresh failure, the partial\nresult includes the receiver SessionID and WindowID. Other failures return\nzero; creation is not rolled back."},"source":{"file":"tmux/pane_create.go","line":115,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.NewPane","product":"core","slug":"tmux-window-newpane"},{"id":"tmux.Pane.NewPane","name":"NewPane","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"NewPane creates a floating pane relative to the receiver's exact linked-pane view. Attach makes the new pane active in that session and winlink; it is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the receiver SessionID and WindowID.","body":"If tmux reports a [PaneID] before a transport or refresh failure, the partial\nresult includes the receiver SessionID and WindowID. Other failures return\nzero; creation is not rolled back."},"source":{"file":"tmux/pane_create.go","line":132,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.NewPane","product":"core","slug":"tmux-pane-newpane"},{"id":"tmux.Window.SplitPane","name":"SplitPane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SplitPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"SplitPane creates a tiled pane in the receiver's exact winlink. Attach makes the new pane active in that session and winlink; it is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the receiver SessionID and WindowID rather than by canonical ID-only refresh. [Pane.Split] is the equivalent operation relative to an existing pane rather than its window.","body":"If tmux reports a [PaneID] before a transport or refresh failure, the partial\nresult also contains the receiver SessionID and WindowID. Other failures\nreturn zero; creation is not rolled back."},"source":{"file":"tmux/pane_create.go","line":302,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SplitPane","product":"core","slug":"tmux-window-splitpane"},{"id":"tmux.Pane.Split","name":"Split","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SplitPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Split creates a tiled pane relative to the receiver's exact linked-pane view. Attach makes the new pane active in that session and winlink; it is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the receiver SessionID and WindowID. Named Split rather than SplitPane to avoid repeating Pane; [Window.SplitPane] is the equivalent operation relative to a window.","body":"If tmux reports a [PaneID] before a transport or refresh failure, the partial\nresult also contains the receiver SessionID and WindowID. Other failures\nreturn zero; creation is not rolled back."},"source":{"file":"tmux/pane_create.go","line":321,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Split","product":"core","slug":"tmux-pane-split"},{"id":"tmux.PaneResizeDirection","name":"PaneResizeDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneResizeDirection selects a directional [Pane.Resize]. Its zero value selects no directional adjustment."},"source":{"file":"tmux/pane_geometry.go","line":10,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneResizeDirection","product":"core","slug":"tmux-paneresizedirection"},{"id":"tmux.PaneResizeDirectionNone","name":"PaneResizeDirectionNone","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionNone omits a directional resize."},"source":{"file":"tmux/pane_geometry.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneResizeDirectionNone","product":"core","slug":"tmux-paneresizedirectionnone"},{"id":"tmux.PaneResizeDirectionUp","name":"PaneResizeDirectionUp","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionUp selects tmux's upward adjustment."},"source":{"file":"tmux/pane_geometry.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneResizeDirectionUp","product":"core","slug":"tmux-paneresizedirectionup"},{"id":"tmux.PaneResizeDirectionDown","name":"PaneResizeDirectionDown","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionDown selects tmux's downward adjustment."},"source":{"file":"tmux/pane_geometry.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneResizeDirectionDown","product":"core","slug":"tmux-paneresizedirectiondown"},{"id":"tmux.PaneResizeDirectionLeft","name":"PaneResizeDirectionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionLeft selects tmux's leftward adjustment."},"source":{"file":"tmux/pane_geometry.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneResizeDirectionLeft","product":"core","slug":"tmux-paneresizedirectionleft"},{"id":"tmux.PaneResizeDirectionRight","name":"PaneResizeDirectionRight","kind":"constant","modifiers":[],"signatures":[],"type":"PaneResizeDirection","doc":{"summary":"PaneResizeDirectionRight selects tmux's rightward adjustment."},"source":{"file":"tmux/pane_geometry.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneResizeDirectionRight","product":"core","slug":"tmux-paneresizedirectionright"},{"id":"tmux.PaneSize","name":"PaneSize","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneSize is an opaque absolute cell count or percentage for [Pane.Resize]. Its zero value omits the dimension. [PaneCells](0) and [PanePercent](0) are explicit sizes, not zero PaneSize values."},"source":{"file":"tmux/pane_geometry.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSize","product":"core","slug":"tmux-panesize"},{"id":"tmux.PaneCells","name":"PaneCells","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"cells","type":"int"}],"returns":"PaneSize"}],"doc":{"summary":"PaneCells returns an explicit pane size measured in cells. Resize validates that cells is nonnegative; zero remains an explicit request."},"source":{"file":"tmux/pane_geometry.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneCells","product":"core","slug":"tmux-panecells"},{"id":"tmux.PanePercent","name":"PanePercent","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"percent","type":"int"}],"returns":"PaneSize"}],"doc":{"summary":"PanePercent returns an explicit percentage of the window size. Resize validates that percent is between 0 and 100 inclusive; zero remains an explicit request."},"source":{"file":"tmux/pane_geometry.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PanePercent","product":"core","slug":"tmux-panepercent"},{"id":"tmux.ResizePaneRequest","name":"ResizePaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ResizePaneRequest selects one resize mode. Direction with Adjustment, dimensions, Zoom, Mouse, and TrimBelow are mutually exclusive modes; Height and Width may be set together. Its zero value sends a bare tmux resize-pane command rather than selecting a mode. When Direction is [PaneResizeDirectionNone], Adjustment must be zero."},"source":{"file":"tmux/pane_geometry.go","line":59,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizePaneRequest","product":"core","slug":"tmux-resizepanerequest"},{"id":"tmux.ResizePaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"PaneResizeDirection","doc":{"summary":"Direction selects a directional resize and requires Adjustment."},"source":{"file":"tmux/pane_geometry.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizePaneRequest.Direction","product":"core","slug":"tmux-resizepanerequest-direction"},{"id":"tmux.ResizePaneRequest.Adjustment","name":"Adjustment","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"int","doc":{"summary":"Adjustment is the positive number of cells moved in Direction. It must be zero when Direction is PaneResizeDirectionNone."},"source":{"file":"tmux/pane_geometry.go","line":64,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizePaneRequest.Adjustment","product":"core","slug":"tmux-resizepanerequest-adjustment"},{"id":"tmux.ResizePaneRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"PaneSize","doc":{"summary":"Height sets an absolute or percentage height. A zero PaneSize omits it."},"source":{"file":"tmux/pane_geometry.go","line":66,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizePaneRequest.Height","product":"core","slug":"tmux-resizepanerequest-height"},{"id":"tmux.ResizePaneRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"PaneSize","doc":{"summary":"Width sets an absolute or percentage width. A zero PaneSize omits it."},"source":{"file":"tmux/pane_geometry.go","line":68,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizePaneRequest.Width","product":"core","slug":"tmux-resizepanerequest-width"},{"id":"tmux.ResizePaneRequest.Zoom","name":"Zoom","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Zoom toggles the pane between its normal layout and full-window zoom."},"source":{"file":"tmux/pane_geometry.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizePaneRequest.Zoom","product":"core","slug":"tmux-resizepanerequest-zoom"},{"id":"tmux.ResizePaneRequest.Mouse","name":"Mouse","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Mouse begins tmux mouse resizing and is meaningful from a mouse binding."},"source":{"file":"tmux/pane_geometry.go","line":72,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizePaneRequest.Mouse","product":"core","slug":"tmux-resizepanerequest-mouse"},{"id":"tmux.ResizePaneRequest.TrimBelow","name":"TrimBelow","kind":"attribute","modifiers":[],"parent":"tmux.ResizePaneRequest","signatures":[],"type":"bool","doc":{"summary":"TrimBelow removes lines below the cursor and refills from history."},"source":{"file":"tmux/pane_geometry.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizePaneRequest.TrimBelow","product":"core","slug":"tmux-resizepanerequest-trimbelow"},{"id":"tmux.Pane.Resize","name":"Resize","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ResizePaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Resize runs tmux resize-pane against the receiver's exact linked session-window-pane target, then refreshes by PaneID. The returned canonical [Pane] may therefore carry a different linked-session or winlink context. If the resize is accepted but refresh fails, Resize returns the original receiver with that error.","body":"Invalid requests fail before execution. A completed command produces a\nredacted [CommandError] only for stderr; nonzero exits without stderr are\nfollowed by refresh. Transport errors return zero and are delivery-ambiguous."},"source":{"file":"tmux/pane_geometry.go","line":86,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Resize","product":"core","slug":"tmux-pane-resize"},{"id":"tmux.Pane.SetWidth","name":"SetWidth","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"width","type":"int"}],"returns":"(Pane, error)"}],"doc":{"summary":"SetWidth resizes the pane to a nonnegative absolute width in cells. Zero is an explicit width. Targeting, refresh, and error semantics match [Pane.Resize]."},"source":{"file":"tmux/pane_geometry.go","line":153,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetWidth","product":"core","slug":"tmux-pane-setwidth"},{"id":"tmux.Pane.SetHeight","name":"SetHeight","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"height","type":"int"}],"returns":"(Pane, error)"}],"doc":{"summary":"SetHeight resizes the pane to a nonnegative absolute height in cells. Zero is an explicit height. Targeting, refresh, and error semantics match [Pane.Resize]."},"source":{"file":"tmux/pane_geometry.go","line":160,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetHeight","product":"core","slug":"tmux-pane-setheight"},{"id":"tmux.Pane.SetTitle","name":"SetTitle","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"title","type":"string"}],"returns":"(Pane, error)"}],"doc":{"summary":"SetTitle sets the title of the receiver's exact linked pane. tmux expands format expressions in title; the value is not a shell command. SetTitle then refreshes by PaneID, so the returned canonical [Pane] may carry a different linked-session or winlink context. If the mutation is accepted but refresh fails, SetTitle returns the original receiver with that error.","body":"Completed stderr produces a redacted [CommandError]; nonzero exits without\nstderr are followed by refresh. Transport errors return zero and are\ndelivery-ambiguous."},"source":{"file":"tmux/pane_geometry.go","line":173,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SetTitle","product":"core","slug":"tmux-pane-settitle"},{"id":"tmux.SendKeysRequest","name":"SendKeysRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SendKeysRequest configures tmux key input. Pointer values are copied before I/O and must not be mutated concurrently.","body":"Command must be nonnil unless Reset, Repeat, or CopyModeCommand is set. A\nnonnil empty Command is an explicit key operand and is followed by Enter\nunless SkipEnter is set. CopyModeCommand takes precedence over Command and\nsuppresses Enter. HexKeys takes precedence over Literal when both are set."},"source":{"file":"tmux/pane_input.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest","product":"core","slug":"tmux-sendkeysrequest"},{"id":"tmux.SendKeysRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"*string","doc":{"summary":"Command is one tmux key operand. Nil selects a flag-only invocation; nonnil, including an empty string, supplies the operand."},"source":{"file":"tmux/pane_input.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.Command","product":"core","slug":"tmux-sendkeysrequest-command"},{"id":"tmux.SendKeysRequest.SkipEnter","name":"SkipEnter","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"SkipEnter prevents the separate Enter key sent after Command."},"source":{"file":"tmux/pane_input.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.SkipEnter","product":"core","slug":"tmux-sendkeysrequest-skipenter"},{"id":"tmux.SendKeysRequest.SuppressHistory","name":"SuppressHistory","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"SuppressHistory prefixes Command with one space. Whether that excludes the text from history depends on the application or shell in the pane."},"source":{"file":"tmux/pane_input.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.SuppressHistory","product":"core","slug":"tmux-sendkeysrequest-suppresshistory"},{"id":"tmux.SendKeysRequest.Literal","name":"Literal","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"Literal disables tmux key-name lookup and treats Command as literal UTF-8. It does not bypass interpretation by the pane's application or shell."},"source":{"file":"tmux/pane_input.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.Literal","product":"core","slug":"tmux-sendkeysrequest-literal"},{"id":"tmux.SendKeysRequest.Reset","name":"Reset","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"Reset asks tmux to reset terminal state before processing key input."},"source":{"file":"tmux/pane_input.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.Reset","product":"core","slug":"tmux-sendkeysrequest-reset"},{"id":"tmux.SendKeysRequest.CopyModeCommand","name":"CopyModeCommand","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"*string","doc":{"summary":"CopyModeCommand sends a tmux copy-mode command instead of Command. A nonnil empty string remains an explicit operand."},"source":{"file":"tmux/pane_input.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.CopyModeCommand","product":"core","slug":"tmux-sendkeysrequest-copymodecommand"},{"id":"tmux.SendKeysRequest.Repeat","name":"Repeat","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"int","doc":{"summary":"Repeat repeats the key input a positive number of times. Zero omits the repeat count."},"source":{"file":"tmux/pane_input.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.Repeat","product":"core","slug":"tmux-sendkeysrequest-repeat"},{"id":"tmux.SendKeysRequest.ExpandFormats","name":"ExpandFormats","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"ExpandFormats asks tmux to expand format expressions in key operands."},"source":{"file":"tmux/pane_input.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.ExpandFormats","product":"core","slug":"tmux-sendkeysrequest-expandformats"},{"id":"tmux.SendKeysRequest.HexKeys","name":"HexKeys","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"HexKeys interprets key operands as hexadecimal ASCII values and takes precedence over Literal."},"source":{"file":"tmux/pane_input.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.HexKeys","product":"core","slug":"tmux-sendkeysrequest-hexkeys"},{"id":"tmux.SendKeysRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the client used by KeyName. Zero leaves client selection to tmux; without KeyName it does not redirect pane input."},"source":{"file":"tmux/pane_input.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.TargetClient","product":"core","slug":"tmux-sendkeysrequest-targetclient"},{"id":"tmux.SendKeysRequest.KeyName","name":"KeyName","kind":"attribute","modifiers":[],"parent":"tmux.SendKeysRequest","signatures":[],"type":"bool","doc":{"summary":"KeyName routes keys through the selected client's key table rather than delivering them to the pane."},"source":{"file":"tmux/pane_input.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeysRequest.KeyName","product":"core","slug":"tmux-sendkeysrequest-keyname"},{"id":"tmux.SendKeySequenceRequest","name":"SendKeySequenceRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SendKeySequenceRequest configures ordered pane key delivery. Keys must contain at least one nonempty operand. SendKeySequence copies Keys before I/O; callers must not mutate it concurrently with the call."},"source":{"file":"tmux/pane_input.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeySequenceRequest","product":"core","slug":"tmux-sendkeysequencerequest"},{"id":"tmux.SendKeySequenceRequest.Keys","name":"Keys","kind":"attribute","modifiers":[],"parent":"tmux.SendKeySequenceRequest","signatures":[],"type":"[]string","doc":{"summary":"Keys are tmux key names sent in order."},"source":{"file":"tmux/pane_input.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeySequenceRequest.Keys","product":"core","slug":"tmux-sendkeysequencerequest-keys"},{"id":"tmux.SendKeySequenceRequest.Literal","name":"Literal","kind":"attribute","modifiers":[],"parent":"tmux.SendKeySequenceRequest","signatures":[],"type":"bool","doc":{"summary":"Literal treats every key as literal UTF-8 instead of a tmux key name."},"source":{"file":"tmux/pane_input.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SendKeySequenceRequest.Literal","product":"core","slug":"tmux-sendkeysequencerequest-literal"},{"id":"tmux.Pane.SendKeySequence","name":"SendKeySequence","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SendKeySequenceRequest"}],"returns":"error"}],"doc":{"summary":"SendKeySequence sends the requested keys to the receiver's exact linked pane in one tmux command. It does not append Enter. Literal changes tmux key parsing but does not bypass interpretation by the pane's application.","body":"A returned error does not establish how many keys tmux delivered."},"source":{"file":"tmux/pane_input.go","line":68,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SendKeySequence","product":"core","slug":"tmux-pane-sendkeysequence"},{"id":"tmux.Pane.SendKeys","name":"SendKeys","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SendKeysRequest"}],"returns":"error"}],"doc":{"summary":"SendKeys invokes tmux send-keys with the receiver's exact linked session-window-pane target. This is tmux key input, not shell execution: Literal only changes tmux key parsing, and any delivered text may still be interpreted by the pane's application. KeyName routes through a client's key table instead of delivering to the pane.","body":"KeyName and TargetClient require tmux 3.4 and follow [UnsupportedPolicy].\n\nA completed nonzero exit or stderr, from either the Command send or the\nseparate Enter, becomes a redacted [CommandError]: Command may carry a\ncaller's secret, so only tmux's exit code is retained. Transport and\ncontext errors are delivery-ambiguous, including between Command and Enter."},"source":{"file":"tmux/pane_input.go","line":139,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SendKeys","product":"core","slug":"tmux-pane-sendkeys"},{"id":"tmux.Pane.Writer","name":"Writer","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"io.Writer"}],"doc":{"summary":"Writer returns the pane's keyboard as an [io.Writer]. Bytes written to it are typed into the pane literally, and each newline is the Enter key, so [fmt.Fprintln] submits a line as a person at the keyboard would. Text with no trailing newline is typed and left on the line.","body":"A write returns once tmux has taken the keys, before the pane's program has\nread them; the program interprets what arrives. A line with a trailing\nnewline costs two tmux commands, the text and a separate Enter; buffering\nwhole lines still costs far less than writing bytes one at a time."},"source":{"file":"tmux/pane_input.go","line":260,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Writer","product":"core","slug":"tmux-pane-writer"},{"id":"tmux.Pane.Enter","name":"Enter","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Enter sends the Enter key to the receiver's exact linked pane. A completed nonzero exit or stderr becomes a redacted [CommandError]; transport errors are delivery-ambiguous."},"source":{"file":"tmux/pane_input.go","line":291,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Enter","product":"core","slug":"tmux-pane-enter"},{"id":"tmux.PrefixKey","name":"PrefixKey","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PrefixKey selects the primary or secondary tmux prefix key. Its zero value selects the primary prefix."},"source":{"file":"tmux/pane_input.go","line":326,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PrefixKey","product":"core","slug":"tmux-prefixkey"},{"id":"tmux.PrefixPrimary","name":"PrefixPrimary","kind":"constant","modifiers":[],"signatures":[],"type":"PrefixKey","doc":{"summary":"PrefixPrimary selects tmux's primary prefix key."},"source":{"file":"tmux/pane_input.go","line":330,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PrefixPrimary","product":"core","slug":"tmux-prefixprimary"},{"id":"tmux.PrefixSecondary","name":"PrefixSecondary","kind":"constant","modifiers":[],"signatures":[],"type":"PrefixKey","doc":{"summary":"PrefixSecondary selects tmux's secondary prefix key."},"source":{"file":"tmux/pane_input.go","line":332,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PrefixSecondary","product":"core","slug":"tmux-prefixsecondary"},{"id":"tmux.Pane.SendPrefix","name":"SendPrefix","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"key","type":"PrefixKey"}],"returns":"error"}],"doc":{"summary":"SendPrefix sends a tmux prefix key to the receiver's exact linked pane. Unsupported PrefixKey values fail before execution. A completed command produces a [CommandError] only when tmux writes stderr; the library-created error retains only the exit code. Nonzero exits without stderr are ignored; transport errors are delivery-ambiguous."},"source":{"file":"tmux/pane_input.go","line":340,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.SendPrefix","product":"core","slug":"tmux-pane-sendprefix"},{"id":"tmux.ClearHistoryRequest","name":"ClearHistoryRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ClearHistoryRequest configures pane history clearing. Its zero value clears scrollback without requesting hyperlink cleanup."},"source":{"file":"tmux/pane_input.go","line":360,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClearHistoryRequest","product":"core","slug":"tmux-clearhistoryrequest"},{"id":"tmux.ClearHistoryRequest.ResetHyperlinks","name":"ResetHyperlinks","kind":"attribute","modifiers":[],"parent":"tmux.ClearHistoryRequest","signatures":[],"type":"bool","doc":{"summary":"ResetHyperlinks also removes hyperlinks. It requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/pane_input.go","line":363,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ClearHistoryRequest.ResetHyperlinks","product":"core","slug":"tmux-clearhistoryrequest-resethyperlinks"},{"id":"tmux.Pane.ClearHistory","name":"ClearHistory","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ClearHistoryRequest"}],"returns":"error"}],"doc":{"summary":"ClearHistory removes scrollback from the receiver's exact linked pane. ResetHyperlinks triggers a version probe before mutation. A completed command produces a redacted [CommandError] only for stderr; nonzero exits without stderr are ignored. Accepted changes are not rolled back."},"source":{"file":"tmux/pane_input.go","line":370,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ClearHistory","product":"core","slug":"tmux-pane-clearhistory"},{"id":"tmux.Pane.Clear","name":"Clear","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Clear types the text \"reset\" and then Enter into the receiver's exact linked pane, the way a person at the keyboard would. Whatever is running reads it: a shell runs reset(1), and an editor receives the word. Use [Pane.Reset] or [Pane.ClearHistory] to act on the pane itself rather than on its program. A transport error may leave the text delivered without Enter."},"source":{"file":"tmux/pane_input.go","line":427,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Clear","product":"core","slug":"tmux-pane-clear"},{"id":"tmux.Pane.Reset","name":"Reset","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Reset submits one tmux command list that resets terminal state and then clears history for the exact linked pane. The mutations are not atomic and may be partial. Only stderr makes a completed command a [CommandError]; nonzero exits without stderr are ignored. Transport errors are delivery-ambiguous."},"source":{"file":"tmux/pane_input.go","line":437,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Reset","product":"core","slug":"tmux-pane-reset"},{"id":"tmux.CopyModeRequest","name":"CopyModeRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CopyModeRequest configures tmux copy mode. Its zero value enters copy mode on the receiver without scrolling. Fields may be combined. tmux resolves the receiver and optional SourcePane before processing Cancel, so a stale target can prevent reset. After resolution, Cancel takes precedence over other actions, though SourcePane validation and the PageDown version probe still occur first."},"source":{"file":"tmux/pane_modes.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeRequest","product":"core","slug":"tmux-copymoderequest"},{"id":"tmux.CopyModeRequest.ScrollUp","name":"ScrollUp","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"ScrollUp enters copy mode one page above the current position."},"source":{"file":"tmux/pane_modes.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeRequest.ScrollUp","product":"core","slug":"tmux-copymoderequest-scrollup"},{"id":"tmux.CopyModeRequest.ExitOnBottom","name":"ExitOnBottom","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"ExitOnBottom makes copy mode exit after scrolling back to the visible screen, until another non-scrolling key disables that behavior."},"source":{"file":"tmux/pane_modes.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeRequest.ExitOnBottom","product":"core","slug":"tmux-copymoderequest-exitonbottom"},{"id":"tmux.CopyModeRequest.MouseDrag","name":"MouseDrag","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"MouseDrag begins a copy-mode mouse drag and is meaningful from a mouse binding."},"source":{"file":"tmux/pane_modes.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeRequest.MouseDrag","product":"core","slug":"tmux-copymoderequest-mousedrag"},{"id":"tmux.CopyModeRequest.PageDown","name":"PageDown","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"PageDown enters copy mode one page below the current position. It requires tmux 3.5 and follows UnsupportedPolicy. Its version probe still occurs when Cancel is set."},"source":{"file":"tmux/pane_modes.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeRequest.PageDown","product":"core","slug":"tmux-copymoderequest-pagedown"},{"id":"tmux.CopyModeRequest.SourcePane","name":"SourcePane","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"PaneID","doc":{"summary":"SourcePane selects a stable pane whose content is copied while the receiver remains the pane placed in copy mode. Zero uses the receiver. A nonzero value is validated by the library and resolved by tmux even when Cancel is set; a stale or nonexistent pane can prevent cancellation."},"source":{"file":"tmux/pane_modes.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeRequest.SourcePane","product":"core","slug":"tmux-copymoderequest-sourcepane"},{"id":"tmux.CopyModeRequest.Cancel","name":"Cancel","kind":"attribute","modifiers":[],"parent":"tmux.CopyModeRequest","signatures":[],"type":"bool","doc":{"summary":"Cancel exits copy mode and any other active pane mode after tmux resolves the receiver and optional SourcePane. A resolution failure prevents the reset; after successful resolution, tmux ignores the other action fields."},"source":{"file":"tmux/pane_modes.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CopyModeRequest.Cancel","product":"core","slug":"tmux-copymoderequest-cancel"},{"id":"tmux.TreeSortOrder","name":"TreeSortOrder","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TreeSortOrder selects one initial tmux choose-tree ordering. Its zero value leaves tmux's configured ordering unchanged."},"source":{"file":"tmux/pane_modes.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TreeSortOrder","product":"core","slug":"tmux-treesortorder"},{"id":"tmux.TreeSortDefault","name":"TreeSortDefault","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortDefault leaves the configured choose-tree ordering unchanged."},"source":{"file":"tmux/pane_modes.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TreeSortDefault","product":"core","slug":"tmux-treesortdefault"},{"id":"tmux.TreeSortIndex","name":"TreeSortIndex","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortIndex orders tree entries by index."},"source":{"file":"tmux/pane_modes.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TreeSortIndex","product":"core","slug":"tmux-treesortindex"},{"id":"tmux.TreeSortName","name":"TreeSortName","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortName orders tree entries by name."},"source":{"file":"tmux/pane_modes.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TreeSortName","product":"core","slug":"tmux-treesortname"},{"id":"tmux.TreeSortTime","name":"TreeSortTime","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortTime orders tree entries by activity time."},"source":{"file":"tmux/pane_modes.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TreeSortTime","product":"core","slug":"tmux-treesorttime"},{"id":"tmux.TreeSortSize","name":"TreeSortSize","kind":"constant","modifiers":[],"signatures":[],"type":"TreeSortOrder","doc":{"summary":"TreeSortSize orders tree entries by size."},"source":{"file":"tmux/pane_modes.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TreeSortSize","product":"core","slug":"tmux-treesortsize"},{"id":"tmux.ChooseTreeRequest","name":"ChooseTreeRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ChooseTreeRequest configures the interactive session and window chooser. Its zero value uses tmux defaults. Format and Filter are copied before execution and must not be mutated concurrently."},"source":{"file":"tmux/pane_modes.go","line":59,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ChooseTreeRequest","product":"core","slug":"tmux-choosetreerequest"},{"id":"tmux.ChooseTreeRequest.SessionsCollapsed","name":"SessionsCollapsed","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"bool","doc":{"summary":"SessionsCollapsed starts with session nodes collapsed."},"source":{"file":"tmux/pane_modes.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ChooseTreeRequest.SessionsCollapsed","product":"core","slug":"tmux-choosetreerequest-sessionscollapsed"},{"id":"tmux.ChooseTreeRequest.WindowsCollapsed","name":"WindowsCollapsed","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"bool","doc":{"summary":"WindowsCollapsed starts with window nodes collapsed."},"source":{"file":"tmux/pane_modes.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ChooseTreeRequest.WindowsCollapsed","product":"core","slug":"tmux-choosetreerequest-windowscollapsed"},{"id":"tmux.ChooseTreeRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"*string","doc":{"summary":"Format is a tmux format expression evaluated for each tree item. Nil leaves the configured format; nonnil empty remains an explicit format."},"source":{"file":"tmux/pane_modes.go","line":66,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ChooseTreeRequest.Format","product":"core","slug":"tmux-choosetreerequest-format"},{"id":"tmux.ChooseTreeRequest.Filter","name":"Filter","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"*TmuxFilter","doc":{"summary":"Filter is a tmux format expression whose truth value selects tree items. Nil omits filtering; nonnil empty remains an explicit expression."},"source":{"file":"tmux/pane_modes.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ChooseTreeRequest.Filter","product":"core","slug":"tmux-choosetreerequest-filter"},{"id":"tmux.ChooseTreeRequest.Sort","name":"Sort","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"TreeSortOrder","doc":{"summary":"Sort selects the initial ordering. Unknown values are rejected before execution."},"source":{"file":"tmux/pane_modes.go","line":72,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ChooseTreeRequest.Sort","product":"core","slug":"tmux-choosetreerequest-sort"},{"id":"tmux.ChooseTreeRequest.Reverse","name":"Reverse","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"bool","doc":{"summary":"Reverse reverses the initial tree ordering."},"source":{"file":"tmux/pane_modes.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ChooseTreeRequest.Reverse","product":"core","slug":"tmux-choosetreerequest-reverse"},{"id":"tmux.ChooseTreeRequest.Zoom","name":"Zoom","kind":"attribute","modifiers":[],"parent":"tmux.ChooseTreeRequest","signatures":[],"type":"bool","doc":{"summary":"Zoom zooms the chooser pane while tree mode is active."},"source":{"file":"tmux/pane_modes.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ChooseTreeRequest.Zoom","product":"core","slug":"tmux-choosetreerequest-zoom"},{"id":"tmux.FindWindowRequest","name":"FindWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"FindWindowRequest configures the interactive window search chooser. Match is a tmux search operand, not a shell command. The zero value searches with an empty glob using tmux's default name, title, and visible-content scopes."},"source":{"file":"tmux/pane_modes.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FindWindowRequest","product":"core","slug":"tmux-findwindowrequest"},{"id":"tmux.FindWindowRequest.Match","name":"Match","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"string","doc":{"summary":"Match is the glob pattern, or regular expression when Regex is true."},"source":{"file":"tmux/pane_modes.go","line":84,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FindWindowRequest.Match","product":"core","slug":"tmux-findwindowrequest-match"},{"id":"tmux.FindWindowRequest.MatchContent","name":"MatchContent","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"MatchContent restricts matching to visible window content, not history."},"source":{"file":"tmux/pane_modes.go","line":86,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FindWindowRequest.MatchContent","product":"core","slug":"tmux-findwindowrequest-matchcontent"},{"id":"tmux.FindWindowRequest.CaseInsensitive","name":"CaseInsensitive","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"CaseInsensitive makes matching ignore case."},"source":{"file":"tmux/pane_modes.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FindWindowRequest.CaseInsensitive","product":"core","slug":"tmux-findwindowrequest-caseinsensitive"},{"id":"tmux.FindWindowRequest.MatchName","name":"MatchName","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"MatchName restricts matching to window names."},"source":{"file":"tmux/pane_modes.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FindWindowRequest.MatchName","product":"core","slug":"tmux-findwindowrequest-matchname"},{"id":"tmux.FindWindowRequest.Regex","name":"Regex","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Regex interprets Match as a regular expression instead of a glob."},"source":{"file":"tmux/pane_modes.go","line":92,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FindWindowRequest.Regex","product":"core","slug":"tmux-findwindowrequest-regex"},{"id":"tmux.FindWindowRequest.MatchTitle","name":"MatchTitle","kind":"attribute","modifiers":[],"parent":"tmux.FindWindowRequest","signatures":[],"type":"bool","doc":{"summary":"MatchTitle restricts matching to window titles."},"source":{"file":"tmux/pane_modes.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FindWindowRequest.MatchTitle","product":"core","slug":"tmux-findwindowrequest-matchtitle"},{"id":"tmux.DisplayPanesRequest","name":"DisplayPanesRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DisplayPanesRequest configures pane-number display for tmux's current client and does not inherit the Pane target. Duration is read during the call, not retained, and must not be mutated concurrently."},"source":{"file":"tmux/pane_modes.go","line":100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPanesRequest","product":"core","slug":"tmux-displaypanesrequest"},{"id":"tmux.DisplayPanesRequest.Duration","name":"Duration","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPanesRequest","signatures":[],"type":"*int","doc":{"summary":"Duration is the display time in milliseconds. Nil uses tmux's display-panes-time option; zero waits for a key press. Negative values are rejected before execution."},"source":{"file":"tmux/pane_modes.go","line":104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPanesRequest.Duration","product":"core","slug":"tmux-displaypanesrequest-duration"},{"id":"tmux.DisplayPanesRequest.NoSelect","name":"NoSelect","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPanesRequest","signatures":[],"type":"bool","doc":{"summary":"NoSelect prevents number keys from selecting a pane, so the display closes only after its duration. With Duration set to zero, it may remain until the context is canceled."},"source":{"file":"tmux/pane_modes.go","line":108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPanesRequest.NoSelect","product":"core","slug":"tmux-displaypanesrequest-noselect"},{"id":"tmux.Pane.CopyMode","name":"CopyMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"CopyModeRequest"}],"returns":"error"}],"doc":{"summary":"CopyMode enters or cancels copy mode using the receiver's exact linked session-window-pane target. PageDown requires tmux 3.5 and follows [UnsupportedPolicy]. A version-probe error stops the operation. tmux resolves the receiver and optional SourcePane before processing Cancel; a stale target can therefore fail without resetting the current mode. Cancel then takes precedence over other actions.","body":"Only stderr produces a redacted [CommandError]; nonzero exits without stderr\nare ignored. Accepted mode changes are not rolled back."},"source":{"file":"tmux/pane_modes.go","line":120,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CopyMode","product":"core","slug":"tmux-pane-copymode"},{"id":"tmux.Pane.ClockMode","name":"ClockMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"ClockMode enters clock mode using the receiver's exact linked target."},"source":{"file":"tmux/pane_modes.go","line":171,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ClockMode","product":"core","slug":"tmux-pane-clockmode"},{"id":"tmux.Pane.ChooseBuffer","name":"ChooseBuffer","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"ChooseBuffer enters tmux's interactive buffer chooser using the receiver's exact linked target. It requires an attached client."},"source":{"file":"tmux/pane_modes.go","line":177,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ChooseBuffer","product":"core","slug":"tmux-pane-choosebuffer"},{"id":"tmux.Pane.ChooseClient","name":"ChooseClient","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"ChooseClient enters tmux's interactive client chooser using the receiver's exact linked target. It requires an attached client."},"source":{"file":"tmux/pane_modes.go","line":183,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ChooseClient","product":"core","slug":"tmux-pane-chooseclient"},{"id":"tmux.Pane.CustomizeMode","name":"CustomizeMode","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CustomizeMode enters tmux's interactive option browser using the receiver's exact linked target. It requires an attached client."},"source":{"file":"tmux/pane_modes.go","line":189,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.CustomizeMode","product":"core","slug":"tmux-pane-customizemode"},{"id":"tmux.Pane.ChooseTree","name":"ChooseTree","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ChooseTreeRequest"}],"returns":"error"}],"doc":{"summary":"ChooseTree enters tmux's interactive session, window, and pane chooser using the receiver's exact linked target. It requires an attached client. Format and Filter are tmux expressions; neither is interpreted by a shell. Unsupported sort values fail before execution. Only stderr produces a redacted [CommandError]; transport errors may leave tree mode active."},"source":{"file":"tmux/pane_modes.go","line":198,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ChooseTree","product":"core","slug":"tmux-pane-choosetree"},{"id":"tmux.Pane.FindWindow","name":"FindWindow","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"FindWindowRequest"}],"returns":"error"}],"doc":{"summary":"FindWindow opens a tree chooser filtered by Match using the receiver's exact linked target. It requires an attached client. Match is passed as one tmux search operand and protected from leading-dash option parsing; it is not a tmux format or shell command. Only stderr produces a redacted [CommandError]; transport errors may leave the chooser open."},"source":{"file":"tmux/pane_modes.go","line":255,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.FindWindow","product":"core","slug":"tmux-pane-findwindow"},{"id":"tmux.Pane.DisplayPanes","name":"DisplayPanes","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayPanesRequest"}],"returns":"error"}],"doc":{"summary":"DisplayPanes displays pane numbers for tmux's current client and waits for the indicator to close. It is client-scoped: the receiver supplies only the server connection and no pane target. A zero request uses tmux's configured duration and permits number-key selection.","body":"Only stderr produces a redacted [CommandError]; nonzero exits without stderr\nare ignored. Cancellation cannot revoke an accepted display."},"source":{"file":"tmux/pane_modes.go","line":291,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.DisplayPanes","product":"core","slug":"tmux-pane-displaypanes"},{"id":"tmux.DisplayPopupRequest","name":"DisplayPopupRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DisplayPopupRequest configures a popup overlay. Pointer and map values are copied before I/O and must not be mutated concurrently. Pointer fields distinguish omission from an explicit empty value, with the Command and StartDirectory behavior documented on those fields.","body":"CloseOnExit and CloseOnSuccess are mutually exclusive. CloseExisting asks\ntmux only to close the existing overlay, so the remaining fields do not\ncreate a replacement. NoBorder makes BorderLines ineffective. When modifying\nan existing popup, NoKeys clears its configured automatic-close flags before\ntmux applies CloseOnExit, CloseOnSuccess, and CloseOnAnyKey from this request.\nNoKeys does not disable keyboard input."},"source":{"file":"tmux/pane_popup.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest","product":"core","slug":"tmux-displaypopuprequest"},{"id":"tmux.DisplayPopupRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Command is interpreted by tmux as a shell command. Nil lets tmux use default-command and then its default shell; nonnil empty is passed explicitly and tmux resolves it directly to the default shell."},"source":{"file":"tmux/pane_popup.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.Command","product":"core","slug":"tmux-displaypopuprequest-command"},{"id":"tmux.DisplayPopupRequest.CloseOnExit","name":"CloseOnExit","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"CloseOnExit closes the overlay whenever Command exits."},"source":{"file":"tmux/pane_popup.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.CloseOnExit","product":"core","slug":"tmux-displaypopuprequest-closeonexit"},{"id":"tmux.DisplayPopupRequest.CloseOnSuccess","name":"CloseOnSuccess","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"CloseOnSuccess closes the overlay only when Command exits successfully."},"source":{"file":"tmux/pane_popup.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.CloseOnSuccess","product":"core","slug":"tmux-displaypopuprequest-closeonsuccess"},{"id":"tmux.DisplayPopupRequest.CloseExisting","name":"CloseExisting","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"CloseExisting closes the selected client's existing overlay and prevents this request from creating a replacement."},"source":{"file":"tmux/pane_popup.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.CloseExisting","product":"core","slug":"tmux-displaypopuprequest-closeexisting"},{"id":"tmux.DisplayPopupRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the client that receives the overlay; zero lets tmux choose. tmux 3.8 and later refuses to host a popup on a control-mode client, which cannot render an overlay, so an explicit control-mode TargetClient is rejected on those versions rather than left as the silent no-op tmux itself returns."},"source":{"file":"tmux/pane_popup.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.TargetClient","product":"core","slug":"tmux-displaypopuprequest-targetclient"},{"id":"tmux.DisplayPopupRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Width is an explicit cell count or percentage and may contain tmux format expressions. Nil lets tmux choose the default width."},"source":{"file":"tmux/pane_popup.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.Width","product":"core","slug":"tmux-displaypopuprequest-width"},{"id":"tmux.DisplayPopupRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Height is an explicit cell count or percentage and may contain tmux format expressions. Nil lets tmux choose the default height."},"source":{"file":"tmux/pane_popup.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.Height","product":"core","slug":"tmux-displaypopuprequest-height"},{"id":"tmux.DisplayPopupRequest.X","name":"X","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"X is a tmux popup position expression and may contain tmux formats. Nil lets tmux choose the horizontal position."},"source":{"file":"tmux/pane_popup.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.X","product":"core","slug":"tmux-displaypopuprequest-x"},{"id":"tmux.DisplayPopupRequest.Y","name":"Y","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Y is a tmux popup position expression and may contain tmux formats. Nil lets tmux choose the vertical position."},"source":{"file":"tmux/pane_popup.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.Y","product":"core","slug":"tmux-displaypopuprequest-y"},{"id":"tmux.DisplayPopupRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"StartDirectory selects the popup working directory. Nil omits the option; nonnil empty is normalized to \".\". The library expands a leading local ~ before tmux expands formats in the resulting value."},"source":{"file":"tmux/pane_popup.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.StartDirectory","product":"core","slug":"tmux-displaypopuprequest-startdirectory"},{"id":"tmux.DisplayPopupRequest.Title","name":"Title","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Title is the popup title format. Nil leaves the tmux default."},"source":{"file":"tmux/pane_popup.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.Title","product":"core","slug":"tmux-displaypopuprequest-title"},{"id":"tmux.DisplayPopupRequest.BorderLines","name":"BorderLines","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"BorderLines selects tmux's border-line style. NoBorder makes it ineffective."},"source":{"file":"tmux/pane_popup.go","line":72,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.BorderLines","product":"core","slug":"tmux-displaypopuprequest-borderlines"},{"id":"tmux.DisplayPopupRequest.Style","name":"Style","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"Style selects the tmux style for the popup interior."},"source":{"file":"tmux/pane_popup.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.Style","product":"core","slug":"tmux-displaypopuprequest-style"},{"id":"tmux.DisplayPopupRequest.BorderStyle","name":"BorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"*string","doc":{"summary":"BorderStyle selects the tmux style for the popup border."},"source":{"file":"tmux/pane_popup.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.BorderStyle","product":"core","slug":"tmux-displaypopuprequest-borderstyle"},{"id":"tmux.DisplayPopupRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment adds validated popup environment entries. Nil and an empty map add none; entries are sent in lexical key order."},"source":{"file":"tmux/pane_popup.go","line":79,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.Environment","product":"core","slug":"tmux-displaypopuprequest-environment"},{"id":"tmux.DisplayPopupRequest.NoBorder","name":"NoBorder","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"NoBorder removes the popup border and makes BorderLines ineffective."},"source":{"file":"tmux/pane_popup.go","line":81,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.NoBorder","product":"core","slug":"tmux-displaypopuprequest-noborder"},{"id":"tmux.DisplayPopupRequest.CloseOnAnyKey","name":"CloseOnAnyKey","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"CloseOnAnyKey lets a nonmouse, nonpaste key dismiss the popup after its command has exited. It does not dismiss the popup while the job is active; tmux continues to send keys to that job."},"source":{"file":"tmux/pane_popup.go","line":85,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.CloseOnAnyKey","product":"core","slug":"tmux-displaypopuprequest-closeonanykey"},{"id":"tmux.DisplayPopupRequest.NoKeys","name":"NoKeys","kind":"attribute","modifiers":[],"parent":"tmux.DisplayPopupRequest","signatures":[],"type":"bool","doc":{"summary":"NoKeys clears automatic-close flags previously configured on an existing popup. Same-request close flags are then applied, and key input remains enabled."},"source":{"file":"tmux/pane_popup.go","line":89,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayPopupRequest.NoKeys","product":"core","slug":"tmux-displaypopuprequest-nokeys"},{"id":"tmux.Pane.DisplayPopup","name":"DisplayPopup","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayPopupRequest"}],"returns":"error"}],"doc":{"summary":"DisplayPopup displays an overlay on the selected client and waits until it closes after command exit or user dismissal. A zero request starts tmux's default command or default shell and may wait indefinitely. The API exposes no popup process handle, stdout, or child exit status.","body":"The command carries the receiver's exact linked session-window-pane target,\nwhich supplies format and working-directory context. TargetClient selects\nthe overlay client; it does not turn the operation into pane delivery. tmux\ninterprets Command as a shell command; outer-parser escaping does not quote\nor neutralize that inner command.\n\nTitle, BorderLines, Style, BorderStyle, Environment, and NoBorder require\ntmux 3.3. CloseOnAnyKey and NoKeys require tmux 3.6. Unsupported fields follow\n[UnsupportedPolicy]. On tmux 3.8 and later, an explicit TargetClient that\nresolves to a control-mode client returns [ErrInvalidServerCommandRequest]\nunless CloseExisting is set: tmux itself answers that combination exactly\nas it answers success, so nothing on the wire would otherwise say the\npopup never ran. CloseExisting is exempt because tmux handles it before\nthat refusal on every version, clearing whatever overlay the target has -\nnothing, for a control-mode client - without creating anything either way.\n\nInvalid fields fail before display. Only stderr produces a redacted\n[CommandError]; nonzero exits without stderr are ignored. Cancellation cannot\ndismiss an accepted popup, which may remain visible."},"source":{"file":"tmux/pane_popup.go","line":137,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.DisplayPopup","product":"core","slug":"tmux-pane-displaypopup"},{"id":"tmux.PasteBufferRequest","name":"PasteBufferRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PasteBufferRequest configures one tmux paste-buffer operation. Its zero value pastes the top buffer, replaces linefeeds with tmux's default carriage-return separator, and uses the version's default control-character handling. Pointer values are copied before I/O and must not be mutated concurrently."},"source":{"file":"tmux/pane_process.go","line":9,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PasteBufferRequest","product":"core","slug":"tmux-pastebufferrequest"},{"id":"tmux.PasteBufferRequest.BufferName","name":"BufferName","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"*string","doc":{"summary":"BufferName selects a named tmux buffer. Nil selects the top buffer; nonnil empty remains an explicit buffer name."},"source":{"file":"tmux/pane_process.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PasteBufferRequest.BufferName","product":"core","slug":"tmux-pastebufferrequest-buffername"},{"id":"tmux.PasteBufferRequest.DeleteAfter","name":"DeleteAfter","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"bool","doc":{"summary":"DeleteAfter asks tmux to delete an existing selected buffer after processing it. Deletion does not prove bytes reached a pane whose input may be disabled."},"source":{"file":"tmux/pane_process.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PasteBufferRequest.DeleteAfter","product":"core","slug":"tmux-pastebufferrequest-deleteafter"},{"id":"tmux.PasteBufferRequest.LinefeedSeparator","name":"LinefeedSeparator","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"bool","doc":{"summary":"LinefeedSeparator preserves linefeeds instead of replacing them with Separator or tmux's default carriage return."},"source":{"file":"tmux/pane_process.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PasteBufferRequest.LinefeedSeparator","product":"core","slug":"tmux-pastebufferrequest-linefeedseparator"},{"id":"tmux.PasteBufferRequest.Bracket","name":"Bracket","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"bool","doc":{"summary":"Bracket surrounds the paste with bracketed-paste control codes when the pane application has requested bracketed paste mode."},"source":{"file":"tmux/pane_process.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PasteBufferRequest.Bracket","product":"core","slug":"tmux-pastebufferrequest-bracket"},{"id":"tmux.PasteBufferRequest.Separator","name":"Separator","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"*string","doc":{"summary":"Separator replaces linefeeds. Nil uses tmux's default carriage return; nonnil empty removes linefeeds. LinefeedSeparator takes precedence."},"source":{"file":"tmux/pane_process.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PasteBufferRequest.Separator","product":"core","slug":"tmux-pastebufferrequest-separator"},{"id":"tmux.PasteBufferRequest.NoVis","name":"NoVis","kind":"attribute","modifiers":[],"parent":"tmux.PasteBufferRequest","signatures":[],"type":"bool","doc":{"summary":"NoVis requests raw bytes and requires tmux 3.7. Older versions already paste raw bytes; see UnsupportedPolicy."},"source":{"file":"tmux/pane_process.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PasteBufferRequest.NoVis","product":"core","slug":"tmux-pastebufferrequest-novis"},{"id":"tmux.PipePaneRequest","name":"PipePaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PipePaneRequest configures a pane pipe. Its flags may be combined. Command is copied before I/O and must not be mutated concurrently."},"source":{"file":"tmux/pane_process.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PipePaneRequest","product":"core","slug":"tmux-pipepanerequest"},{"id":"tmux.PipePaneRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.PipePaneRequest","signatures":[],"type":"*string","doc":{"summary":"Command is a shell command for tmux's pipe process. Nil closes the current pipe; nonnil empty is an explicit operand that tmux also treats as stop."},"source":{"file":"tmux/pane_process.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PipePaneRequest.Command","product":"core","slug":"tmux-pipepanerequest-command"},{"id":"tmux.PipePaneRequest.OutputOnly","name":"OutputOnly","kind":"attribute","modifiers":[],"parent":"tmux.PipePaneRequest","signatures":[],"type":"bool","doc":{"summary":"OutputOnly connects pane output to the pipe command's standard input. When neither direction is set, tmux uses this direction by default."},"source":{"file":"tmux/pane_process.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PipePaneRequest.OutputOnly","product":"core","slug":"tmux-pipepanerequest-outputonly"},{"id":"tmux.PipePaneRequest.InputOnly","name":"InputOnly","kind":"attribute","modifiers":[],"parent":"tmux.PipePaneRequest","signatures":[],"type":"bool","doc":{"summary":"InputOnly connects the pipe command's standard output to pane input."},"source":{"file":"tmux/pane_process.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PipePaneRequest.InputOnly","product":"core","slug":"tmux-pipepanerequest-inputonly"},{"id":"tmux.PipePaneRequest.Toggle","name":"Toggle","kind":"attribute","modifiers":[],"parent":"tmux.PipePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Toggle closes an existing pipe or opens Command when no pipe exists."},"source":{"file":"tmux/pane_process.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PipePaneRequest.Toggle","product":"core","slug":"tmux-pipepanerequest-toggle"},{"id":"tmux.Pane.Respawn","name":"Respawn","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RespawnRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Respawn restarts the process in the receiver's exact linked pane on tmux 3.2a or newer. Command, when present, is passed as one tmux shell-command operand; Go neither executes it locally nor adds inner-shell quoting. Final semicolon protection applies only to tmux's outer command parser. See [RespawnRequest] for zero-value, directory, environment, and Kill behavior.","body":"Respawn refreshes by PaneID, so the returned canonical [Pane] may carry a\ndifferent linked-session or winlink context. The process may be restarted\nbefore refresh fails; in that case Respawn returns the original receiver and\nthe refresh error. Earlier failures return zero. Completed stderr produces a\nredacted [CommandError]; a nonzero exit without stderr is followed by refresh."},"source":{"file":"tmux/pane_process.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Respawn","product":"core","slug":"tmux-pane-respawn"},{"id":"tmux.Pane.PasteBuffer","name":"PasteBuffer","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PasteBufferRequest"}],"returns":"error"}],"doc":{"summary":"PasteBuffer pastes a named or top buffer into the receiver's exact linked pane. DeleteAfter requests deletion after tmux processes an existing buffer; an exited target or missing named buffer fails before deletion, while deletion after disabled pane input does not prove byte delivery.","body":"NoVis requires tmux 3.7 and follows [UnsupportedPolicy]; older versions\nalready paste raw bytes. Only stderr produces a redacted [CommandError];\nnonzero exits without stderr are ignored. Accepted paste or deletion effects\nare not rolled back."},"source":{"file":"tmux/pane_process.go","line":134,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.PasteBuffer","product":"core","slug":"tmux-pane-pastebuffer"},{"id":"tmux.Pane.Pipe","name":"Pipe","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PipePaneRequest"}],"returns":"error"}],"doc":{"summary":"Pipe starts, toggles, or stops piping for the receiver's exact linked pane. tmux expands formats and time formats in Command before running it with sh -c. The library's protection for a final semicolon applies only to tmux's outer command parser; it does not quote or neutralize the child shell.","body":"A nil Command, and an explicit empty Command under tmux semantics, stops the\ncurrent pipe. Successful return means tmux installed, toggled, or stopped the\npipe; it does not report child-shell success or lifetime. Only stderr produces\na redacted [CommandError]. Accepted pipe changes are not rolled back."},"source":{"file":"tmux/pane_process.go","line":207,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Pipe","product":"core","slug":"tmux-pane-pipe"},{"id":"tmux.MovePaneRequest","name":"MovePaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MovePaneRequest configures move-pane on tmux 3.2a or later. Its zero value is invalid: exactly one complete TargetPane or TargetWindow handle is required. Cross-object handles must be proven to share a daemon through connection state or the same nonempty SocketPath; matching socket names alone are insufficient. Size and Percentage are mutually exclusive. Invalid enum, target, size, and percentage values are rejected before execution.","body":"Size pointers are read during the call and not retained; nil omits the mode\nand nonnil is explicit. Do not mutate them concurrently."},"source":{"file":"tmux/pane_relocate.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MovePaneRequest","product":"core","slug":"tmux-movepanerequest"},{"id":"tmux.MovePaneRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"Pane","doc":{"summary":"TargetPane selects an exact destination pane; a zero Pane omits it."},"source":{"file":"tmux/pane_relocate.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MovePaneRequest.TargetPane","product":"core","slug":"tmux-movepanerequest-targetpane"},{"id":"tmux.MovePaneRequest.TargetWindow","name":"TargetWindow","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"Window","doc":{"summary":"TargetWindow selects an exact destination winlink; a zero Window omits it."},"source":{"file":"tmux/pane_relocate.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MovePaneRequest.TargetWindow","product":"core","slug":"tmux-movepanerequest-targetwindow"},{"id":"tmux.MovePaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets tmux make the moved pane active in the destination winlink."},"source":{"file":"tmux/pane_relocate.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MovePaneRequest.Attach","product":"core","slug":"tmux-movepanerequest-attach"},{"id":"tmux.MovePaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"PaneDirection","doc":{"summary":"Direction selects placement relative to the destination; zero means below."},"source":{"file":"tmux/pane_relocate.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MovePaneRequest.Direction","product":"core","slug":"tmux-movepanerequest-direction"},{"id":"tmux.MovePaneRequest.FullWindow","name":"FullWindow","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"bool","doc":{"summary":"FullWindow lets the moved pane span the full destination window."},"source":{"file":"tmux/pane_relocate.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MovePaneRequest.FullWindow","product":"core","slug":"tmux-movepanerequest-fullwindow"},{"id":"tmux.MovePaneRequest.Size","name":"Size","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"*int","doc":{"summary":"Size selects a nonnegative absolute pane size; nil omits it."},"source":{"file":"tmux/pane_relocate.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MovePaneRequest.Size","product":"core","slug":"tmux-movepanerequest-size"},{"id":"tmux.MovePaneRequest.Percentage","name":"Percentage","kind":"attribute","modifiers":[],"parent":"tmux.MovePaneRequest","signatures":[],"type":"*int","doc":{"summary":"Percentage selects a size from 0 through 100; nil omits it."},"source":{"file":"tmux/pane_relocate.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MovePaneRequest.Percentage","product":"core","slug":"tmux-movepanerequest-percentage"},{"id":"tmux.JoinPaneRequest","name":"JoinPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"JoinPaneRequest configures join-pane with the same target, cross-daemon, sizing, validation, and pointer-ownership rules as [MovePaneRequest]."},"source":{"file":"tmux/pane_relocate.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.JoinPaneRequest","product":"core","slug":"tmux-joinpanerequest"},{"id":"tmux.JoinPaneRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"Pane","doc":{"summary":"TargetPane selects an exact destination pane; a zero Pane omits it."},"source":{"file":"tmux/pane_relocate.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.JoinPaneRequest.TargetPane","product":"core","slug":"tmux-joinpanerequest-targetpane"},{"id":"tmux.JoinPaneRequest.TargetWindow","name":"TargetWindow","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"Window","doc":{"summary":"TargetWindow selects an exact destination winlink; a zero Window omits it."},"source":{"file":"tmux/pane_relocate.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.JoinPaneRequest.TargetWindow","product":"core","slug":"tmux-joinpanerequest-targetwindow"},{"id":"tmux.JoinPaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets tmux make the joined pane active in the destination winlink."},"source":{"file":"tmux/pane_relocate.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.JoinPaneRequest.Attach","product":"core","slug":"tmux-joinpanerequest-attach"},{"id":"tmux.JoinPaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"PaneDirection","doc":{"summary":"Direction selects placement relative to the destination; zero means below."},"source":{"file":"tmux/pane_relocate.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.JoinPaneRequest.Direction","product":"core","slug":"tmux-joinpanerequest-direction"},{"id":"tmux.JoinPaneRequest.FullWindow","name":"FullWindow","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"bool","doc":{"summary":"FullWindow lets the joined pane span the full destination window."},"source":{"file":"tmux/pane_relocate.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.JoinPaneRequest.FullWindow","product":"core","slug":"tmux-joinpanerequest-fullwindow"},{"id":"tmux.JoinPaneRequest.Size","name":"Size","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Size selects a nonnegative absolute pane size; nil omits it."},"source":{"file":"tmux/pane_relocate.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.JoinPaneRequest.Size","product":"core","slug":"tmux-joinpanerequest-size"},{"id":"tmux.JoinPaneRequest.Percentage","name":"Percentage","kind":"attribute","modifiers":[],"parent":"tmux.JoinPaneRequest","signatures":[],"type":"*int","doc":{"summary":"Percentage selects a size from 0 through 100; nil omits it."},"source":{"file":"tmux/pane_relocate.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.JoinPaneRequest.Percentage","product":"core","slug":"tmux-joinpanerequest-percentage"},{"id":"tmux.BreakPaneRequest","name":"BreakPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"BreakPaneRequest configures break-pane on tmux 3.2a or later. Its zero value moves the receiver to a detached new window with tmux's default name, except for the documented raw-version 3.7 workaround in [Pane.BreakPane]. Empty Name means omission and is validated before the version probe."},"source":{"file":"tmux/pane_relocate.go","line":59,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BreakPaneRequest","product":"core","slug":"tmux-breakpanerequest"},{"id":"tmux.BreakPaneRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.BreakPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets the new winlink become current in the receiver session."},"source":{"file":"tmux/pane_relocate.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BreakPaneRequest.Attach","product":"core","slug":"tmux-breakpanerequest-attach"},{"id":"tmux.BreakPaneRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.BreakPaneRequest","signatures":[],"type":"string","doc":{"summary":"Name requests the new window name; empty normally lets tmux choose."},"source":{"file":"tmux/pane_relocate.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BreakPaneRequest.Name","product":"core","slug":"tmux-breakpanerequest-name"},{"id":"tmux.Pane.Move","name":"Move","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"MovePaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Move relocates the receiver pane into one exact destination with tmux's move-pane command. Unless Attach is set, the destination's active-pane selection remains unchanged; Attach is not a global client-focus guarantee. The returned [Pane] is freshly materialized in the destination SessionID and WindowID rather than by canonical ID-only refresh.","body":"Removing the sole pane destroys the emptied source window and all of its\nwinlinks. Affected source sessions preserve their current selection unless\nthat window was current, in which case they select another. A session left\nwithout windows is destroyed and detaches its clients.\n\nIf exact refresh fails after the command, Move returns a partial Pane with\nthe receiver PaneID and predicted destination context. Other failures return\nzero. Transport errors are delivery-ambiguous and no rollback is attempted."},"source":{"file":"tmux/pane_relocate.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Move","product":"core","slug":"tmux-pane-move"},{"id":"tmux.Pane.Join","name":"Join","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"JoinPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Join relocates the receiver with join-pane. Its selection, source-destruction, partial-result, and delivery behavior matches [Pane.Move]."},"source":{"file":"tmux/pane_relocate.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Join","product":"core","slug":"tmux-pane-join"},{"id":"tmux.Pane.BreakPane","name":"BreakPane","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"BreakPaneRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"BreakPane moves the receiver into a new window in its exact session. Attach lets that new winlink become current in the session; it is not a global client-focus guarantee. The returned [Window] is freshly materialized in the receiver SessionID rather than by canonical ID-only refresh.","body":"Before tmux 3.6, the sole-pane path may print no ID and retain WindowID; this\nmethod refreshes that identity. Raw version \"3.7\" alone uses a placeholder\nname and optional second rename; with an empty Name, the window may remain\nnamed \"libtmux\". Suffixed 3.7 releases do not use the workaround.\n\nAfter a reported ID, rename failure, or refresh failure, the partial result\ncarries the known WindowID and receiver session with Index -1. Earlier\nfailures return zero; no mutation is rolled back."},"source":{"file":"tmux/pane_relocate.go","line":119,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.BreakPane","product":"core","slug":"tmux-pane-breakpane"},{"id":"tmux.PaneText","name":"PaneText","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneText is what a pane wrote after an observation's baseline, as the text a person would read: escape sequences removed, UTF-8 joined across writes, and each carriage return or backspace that would overwrite text starting a new line, so nothing the program wrote is hidden."},"source":{"file":"tmux/pane_wait.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneText","product":"core","slug":"tmux-panetext"},{"id":"tmux.PaneText.Text","name":"Text","kind":"attribute","modifiers":[],"parent":"tmux.PaneText","signatures":[],"type":"string","doc":{"summary":"Text is the most recent output, up to a mebibyte."},"source":{"file":"tmux/pane_wait.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneText.Text","product":"core","slug":"tmux-panetext-text"},{"id":"tmux.PaneText.DroppedBytes","name":"DroppedBytes","kind":"attribute","modifiers":[],"parent":"tmux.PaneText","signatures":[],"type":"int","doc":{"summary":"DroppedBytes counts what was dropped from the front of Text to keep it within that bound."},"source":{"file":"tmux/pane_wait.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneText.DroppedBytes","product":"core","slug":"tmux-panetext-droppedbytes"},{"id":"tmux.PaneText.DroppedLines","name":"DroppedLines","kind":"attribute","modifiers":[],"parent":"tmux.PaneText","signatures":[],"type":"int","doc":{"summary":"DroppedLines counts the line ends among those dropped bytes."},"source":{"file":"tmux/pane_wait.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneText.DroppedLines","product":"core","slug":"tmux-panetext-droppedlines"},{"id":"tmux.PaneObservation.WaitFor","name":"WaitFor","kind":"method","modifiers":[],"parent":"tmux.PaneObservation","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"match","type":"func(text string) bool"}],"returns":"(PaneText, error)"}],"doc":{"summary":"WaitFor reads what the pane writes after the observation's baseline and calls match with all of it each time the pane writes, until match reports true, ctx ends, or the observation is lost. It returns the text match accepted, or what was read before the error. tmux pushes each write as it happens, so nothing is polled.","body":"The baseline is not part of the text: check [PaneObservation.Baseline] for\nwhat was on screen already. A shell echoes what is typed into it, and the\necho is output like any other, so open the observation before typing and\nmatch on what the command prints rather than on the command itself.\n\nWrites that arrived together reach match once. Exactly one read may run at\na time, as for [PaneObservation.NextNotification], and a malformed\nnotification is skipped as [PaneObservation.Reader] skips it."},"source":{"file":"tmux/pane_wait.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneObservation.WaitFor","product":"core","slug":"tmux-paneobservation-waitfor"},{"id":"tmux.ErrPlan","name":"ErrPlan","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrPlan identifies a plan that cannot run as recorded. It is matched by errors.Is for [PlanError]."},"source":{"file":"tmux/plan.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrPlan","product":"core","slug":"tmux-errplan"},{"id":"tmux.PlanError","name":"PlanError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PlanError reports a plan this package refused before sending anything to tmux. It matches [ErrPlan] through errors.Is; callers can recover Step and Reason with errors.As."},"source":{"file":"tmux/plan.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanError","product":"core","slug":"tmux-planerror"},{"id":"tmux.PlanError.Step","name":"Step","kind":"attribute","modifiers":[],"parent":"tmux.PlanError","signatures":[],"type":"int","doc":{"summary":"Step is the zero-based index of the operation at fault."},"source":{"file":"tmux/plan.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanError.Step","product":"core","slug":"tmux-planerror-step"},{"id":"tmux.PlanError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.PlanError","signatures":[],"type":"string","doc":{"summary":"Reason describes what makes the plan unrunnable."},"source":{"file":"tmux/plan.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanError.Reason","product":"core","slug":"tmux-planerror-reason"},{"id":"tmux.PlanError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.PlanError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/plan.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanError.Error","product":"core","slug":"tmux-planerror-error"},{"id":"tmux.PlanError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.PlanError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes PlanError compatible with ErrPlan."},"source":{"file":"tmux/plan.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanError.Unwrap","product":"core","slug":"tmux-planerror-unwrap"},{"id":"tmux.Ref","name":"Ref","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Ref addresses an existing object or one an earlier [Plan] step will create. This permits forward construction without tmux I/O. The zero Ref addresses nothing and makes a targeted operation fail validation."},"source":{"file":"tmux/plan.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Ref","product":"core","slug":"tmux-ref"},{"id":"tmux.Session.Ref","name":"Ref","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"Ref"}],"doc":{"summary":"Ref returns a [Ref] addressing the receiver."},"source":{"file":"tmux/plan.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Ref","product":"core","slug":"tmux-session-ref"},{"id":"tmux.Window.Ref","name":"Ref","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"Ref"}],"doc":{"summary":"Ref returns a [Ref] addressing the receiver."},"source":{"file":"tmux/plan.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Ref","product":"core","slug":"tmux-window-ref"},{"id":"tmux.Pane.Ref","name":"Ref","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[],"returns":"Ref"}],"doc":{"summary":"Ref returns a [Ref] addressing the receiver."},"source":{"file":"tmux/plan.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Ref","product":"core","slug":"tmux-pane-ref"},{"id":"tmux.SessionRef","name":"SessionRef","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"id","type":"SessionID"}],"returns":"Ref"}],"doc":{"summary":"SessionRef returns a selector-relative [Ref] addressing a session by ID, for a caller holding an identifier rather than a materialized record."},"source":{"file":"tmux/plan.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SessionRef","product":"core","slug":"tmux-sessionref"},{"id":"tmux.WindowRef","name":"WindowRef","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"id","type":"WindowID"}],"returns":"Ref"}],"doc":{"summary":"WindowRef returns a selector-relative [Ref] addressing a window by ID, for a caller holding an identifier rather than a materialized record."},"source":{"file":"tmux/plan.go","line":73,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowRef","product":"core","slug":"tmux-windowref"},{"id":"tmux.PaneRef","name":"PaneRef","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"id","type":"PaneID"}],"returns":"Ref"}],"doc":{"summary":"PaneRef returns a selector-relative [Ref] addressing a pane by ID, for a caller holding an identifier rather than a materialized record."},"source":{"file":"tmux/plan.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneRef","product":"core","slug":"tmux-paneref"},{"id":"tmux.Ref.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Ref","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the target a Ref resolves to, or a placeholder naming the step that will produce it."},"source":{"file":"tmux/plan.go","line":81,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Ref.String","product":"core","slug":"tmux-ref-string"},{"id":"tmux.Op","name":"Op","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Op is one tmux command a [Plan] has recorded but not run. Build one with a [Plan] method rather than directly; the zero value records nothing."},"source":{"file":"tmux/plan.go","line":93,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Op","product":"core","slug":"tmux-op"},{"id":"tmux.Op.Chainable","name":"Chainable","kind":"method","modifiers":[],"parent":"tmux.Op","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"Chainable reports whether the operation may share a tmux invocation with others, which is what a [Planner] groups on."},"source":{"file":"tmux/plan.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Op.Chainable","product":"core","slug":"tmux-op-chainable"},{"id":"tmux.Op.Command","name":"Command","kind":"method","modifiers":[],"parent":"tmux.Op","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Command returns the tmux command the operation records."},"source":{"file":"tmux/plan.go","line":114,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Op.Command","product":"core","slug":"tmux-op-command"},{"id":"tmux.Plan","name":"Plan","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Plan records ordered tmux commands for later execution. It groups commands that need no answer and lets later steps reference objects earlier steps create.","body":"Recording touches nothing. [Plan.Preview] renders what would be sent and\n[Plan.Explain] says how it would be grouped, both without a server;\n[Plan.Run] is the only method that reaches tmux.\n\nA Plan is not safe for concurrent use."},"source":{"file":"tmux/plan.go","line":127,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan","product":"core","slug":"tmux-plan"},{"id":"tmux.NewPlan","name":"NewPlan","kind":"function","modifiers":[],"signatures":[{"params":[],"returns":"*Plan"}],"doc":{"summary":"NewPlan returns an empty [Plan]."},"source":{"file":"tmux/plan.go","line":141,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewPlan","product":"core","slug":"tmux-newplan"},{"id":"tmux.Plan.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns how many operations the plan has recorded."},"source":{"file":"tmux/plan.go","line":153,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.Len","product":"core","slug":"tmux-plan-len"},{"id":"tmux.Plan.Ops","name":"Ops","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[],"returns":"[]Op"}],"doc":{"summary":"Ops returns the recorded operations, in order, for a [Planner] to group."},"source":{"file":"tmux/plan.go","line":156,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.Ops","product":"core","slug":"tmux-plan-ops"},{"id":"tmux.Dispatch","name":"Dispatch","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Dispatch is one tmux invocation and the operations it carries. A dispatch holding more than one operation is sent as a tmux command list."},"source":{"file":"tmux/plan.go","line":247,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Dispatch","product":"core","slug":"tmux-dispatch"},{"id":"tmux.Dispatch.Ops","name":"Ops","kind":"attribute","modifiers":[],"parent":"tmux.Dispatch","signatures":[],"type":"[]int","doc":{"summary":"Ops are the indices of the operations this dispatch carries, in order."},"source":{"file":"tmux/plan.go","line":249,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Dispatch.Ops","product":"core","slug":"tmux-dispatch-ops"},{"id":"tmux.Dispatch.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.Dispatch","signatures":[],"type":"string","doc":{"summary":"Reason says why the dispatch ends where it does. It is \"chained\" for a command list, \"creates\" for an operation whose new object's ID a later step needs, \"captures\" for one whose output the caller reads, and \"alone\" for a chainable operation with nothing beside it to chain to."},"source":{"file":"tmux/plan.go","line":254,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Dispatch.Reason","product":"core","slug":"tmux-dispatch-reason"},{"id":"tmux.Planner","name":"Planner","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Planner groups a plan's operations into tmux invocations.","body":"Dispatches must contain every operation exactly once and in recorded order.\n[Plan.Run] validates this before reaching tmux.\n\nOperations with [Op.Chainable] false must run alone because command-list\nstdout cannot be attributed to an individual operation."},"source":{"file":"tmux/plan.go","line":264,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Planner","product":"core","slug":"tmux-planner"},{"id":"tmux.Sequential","name":"Sequential","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Sequential sends every operation as its own tmux invocation. It is the simplest correct planner, and useful as a baseline: a plan produces the same results through it as through [Folding], at one invocation per operation."},"source":{"file":"tmux/plan.go","line":272,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Sequential","product":"core","slug":"tmux-sequential"},{"id":"tmux.Sequential.Plan","name":"Plan","kind":"method","modifiers":[],"parent":"tmux.Sequential","signatures":[{"params":[{"name":"ops","type":"[]Op"}],"returns":"[]Dispatch"}],"doc":{"summary":"Plan returns one dispatch per operation."},"source":{"file":"tmux/plan.go","line":275,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Sequential.Plan","product":"core","slug":"tmux-sequential-plan"},{"id":"tmux.Folding","name":"Folding","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Folding groups each run of operations that neither answer nor create into one tmux command list, and sends the rest alone. It is what [Plan.Run] uses."},"source":{"file":"tmux/plan.go","line":292,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Folding","product":"core","slug":"tmux-folding"},{"id":"tmux.Folding.Plan","name":"Plan","kind":"method","modifiers":[],"parent":"tmux.Folding","signatures":[{"params":[{"name":"ops","type":"[]Op"}],"returns":"[]Dispatch"}],"doc":{"summary":"Plan returns the dispatches for ops, grouping consecutive chainable runs."},"source":{"file":"tmux/plan.go","line":295,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Folding.Plan","product":"core","slug":"tmux-folding-plan"},{"id":"tmux.Plan.Explain","name":"Explain","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[],"returns":"[]Dispatch"}],"doc":{"summary":"Explain reports how [Plan.Run] would group the recorded operations into tmux commands, and why each group ends where it does. It runs no commands.","body":"The number of dispatches is the number of tmux invocations."},"source":{"file":"tmux/plan.go","line":332,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.Explain","product":"core","slug":"tmux-plan-explain"},{"id":"tmux.Plan.ExplainWith","name":"ExplainWith","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"planner","type":"Planner"}],"returns":"[]Dispatch"}],"doc":{"summary":"ExplainWith reports how planner would group the recorded operations."},"source":{"file":"tmux/plan.go","line":335,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.ExplainWith","product":"core","slug":"tmux-plan-explainwith"},{"id":"tmux.Plan.Preview","name":"Preview","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"version","type":"Version"}],"returns":"([][]string, error)"}],"doc":{"summary":"Preview renders every recorded operation's argument vector without running anything, for the tmux version given.","body":"An entry is nil when it references an object an earlier step has not created.\n\nOther render failures return the entries completed before the error. Preview\ncatches them before a non-atomic run can partially mutate tmux."},"source":{"file":"tmux/plan.go","line":346,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.Preview","product":"core","slug":"tmux-plan-preview"},{"id":"tmux.PlanResult","name":"PlanResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PlanResult reports what running a [Plan] did, one entry per recorded operation, in the order they were recorded."},"source":{"file":"tmux/plan.go","line":372,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanResult","product":"core","slug":"tmux-planresult"},{"id":"tmux.PlanResult.Ops","name":"Ops","kind":"attribute","modifiers":[],"parent":"tmux.PlanResult","signatures":[],"type":"[]OpResult","doc":{"summary":"Ops holds one result per recorded operation, in the order recorded."},"source":{"file":"tmux/plan.go","line":374,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanResult.Ops","product":"core","slug":"tmux-planresult-ops"},{"id":"tmux.PlanResult.OK","name":"OK","kind":"method","modifiers":[],"parent":"tmux.PlanResult","signatures":[{"params":[],"returns":"bool"}],"doc":{"summary":"OK reports whether every operation completed."},"source":{"file":"tmux/plan.go","line":378,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanResult.OK","product":"core","slug":"tmux-planresult-ok"},{"id":"tmux.PlanResult.Err","name":"Err","kind":"method","modifiers":[],"parent":"tmux.PlanResult","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Err returns the first failed or indeterminate operation's error, or nil when every operation completed."},"source":{"file":"tmux/plan.go","line":389,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PlanResult.Err","product":"core","slug":"tmux-planresult-err"},{"id":"tmux.OpStatus","name":"OpStatus","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OpStatus reports what became of one operation in a plan."},"source":{"file":"tmux/plan.go","line":399,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpStatus","product":"core","slug":"tmux-opstatus"},{"id":"tmux.OpComplete","name":"OpComplete","kind":"constant","modifiers":[],"signatures":[],"type":"OpStatus","doc":{"summary":"OpComplete is an operation tmux ran successfully."},"source":{"file":"tmux/plan.go","line":403,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpComplete","product":"core","slug":"tmux-opcomplete"},{"id":"tmux.OpFailed","name":"OpFailed","kind":"constant","modifiers":[],"signatures":[],"type":"OpStatus","doc":{"summary":"OpFailed is an operation tmux refused. Only an operation sent alone can receive this status."},"source":{"file":"tmux/plan.go","line":406,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpFailed","product":"core","slug":"tmux-opfailed"},{"id":"tmux.OpIndeterminate","name":"OpIndeterminate","kind":"constant","modifiers":[],"signatures":[],"type":"OpStatus","doc":{"summary":"OpIndeterminate is an operation dispatched without enough reply evidence to prove whether tmux applied or rejected it."},"source":{"file":"tmux/plan.go","line":409,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpIndeterminate","product":"core","slug":"tmux-opindeterminate"},{"id":"tmux.OpSkipped","name":"OpSkipped","kind":"constant","modifiers":[],"signatures":[],"type":"OpStatus","doc":{"summary":"OpSkipped is an operation the plan did not dispatch because an earlier dispatch failed or became indeterminate."},"source":{"file":"tmux/plan.go","line":412,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpSkipped","product":"core","slug":"tmux-opskipped"},{"id":"tmux.OpStatus.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.OpStatus","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer."},"source":{"file":"tmux/plan.go","line":416,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpStatus.String","product":"core","slug":"tmux-opstatus-string"},{"id":"tmux.OpResult","name":"OpResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"OpResult is what one operation in a [Plan] produced."},"source":{"file":"tmux/plan.go","line":432,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpResult","product":"core","slug":"tmux-opresult"},{"id":"tmux.OpResult.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"string","doc":{"summary":"Command is the tmux command the operation recorded."},"source":{"file":"tmux/plan.go","line":434,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpResult.Command","product":"core","slug":"tmux-opresult-command"},{"id":"tmux.OpResult.Status","name":"Status","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"OpStatus","doc":{"summary":"Status reports what became of the operation."},"source":{"file":"tmux/plan.go","line":436,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpResult.Status","product":"core","slug":"tmux-opresult-status"},{"id":"tmux.OpResult.Created","name":"Created","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"string","doc":{"summary":"Created is the ID tmux reported for an object this operation brought into being, and is empty for every other operation."},"source":{"file":"tmux/plan.go","line":439,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpResult.Created","product":"core","slug":"tmux-opresult-created"},{"id":"tmux.OpResult.Stdout","name":"Stdout","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"[]string","doc":{"summary":"Stdout holds the operation's output, for an operation that captures it."},"source":{"file":"tmux/plan.go","line":441,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpResult.Stdout","product":"core","slug":"tmux-opresult-stdout"},{"id":"tmux.OpResult.Err","name":"Err","kind":"attribute","modifiers":[],"parent":"tmux.OpResult","signatures":[],"type":"error","doc":{"summary":"Err is the failure or uncertainty for a failed or indeterminate operation."},"source":{"file":"tmux/plan.go","line":443,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.OpResult.Err","product":"core","slug":"tmux-opresult-err"},{"id":"tmux.Plan.Run","name":"Run","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"server","type":"Server"}],"returns":"(PlanResult, error)"}],"doc":{"summary":"Run sends the recorded operations through server and returns one result per step.","body":"Operations that need no answer travel together in one tmux command list;\n[Plan.Explain] reports the grouping. Run stops at the first failed or\nindeterminate dispatch; later operations are [OpSkipped].\n\nTmux refusals appear in results. Transport, context, and [PlanError] failures\nare returned. Run is not atomic; completed mutations remain after failure."},"source":{"file":"tmux/plan.go","line":454,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.Run","product":"core","slug":"tmux-plan-run"},{"id":"tmux.Plan.RunWith","name":"RunWith","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"server","type":"Server"},{"name":"planner","type":"Planner"}],"returns":"(PlanResult, error)"}],"doc":{"summary":"RunWith runs the plan with planner deciding dispatch grouping. Successful execution produces planner-independent results, but every operation in a failed grouped dispatch is [OpIndeterminate]. Use [Sequential] for exact attribution."},"source":{"file":"tmux/plan.go","line":462,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.RunWith","product":"core","slug":"tmux-plan-runwith"},{"id":"tmux.Plan.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"args","type":"string"}]}],"doc":{"summary":"Cmd records raw tmux arguments targeted at target.","body":"It can target an object an earlier step creates. A zero [Ref] records an\nuntargeted server command.\n\nThe recorded command is assumed to neither print output the caller reads nor\ncreate an object, which is what lets it share a dispatch with its neighbours.\nUse [Plan.CmdCapture] for one whose output is the point."},"source":{"file":"tmux/plan.go","line":731,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.Cmd","product":"core","slug":"tmux-plan-cmd"},{"id":"tmux.Plan.CmdCapture","name":"CmdCapture","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"args","type":"string"}]}],"doc":{"summary":"CmdCapture records raw tmux arguments whose output is returned in the step's [OpResult], and is otherwise [Plan.Cmd].","body":"Reading output is what stops an operation sharing a dispatch, so this is sent\non its own; [Plan.Explain] reports that."},"source":{"file":"tmux/plan.go","line":740,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.CmdCapture","product":"core","slug":"tmux-plan-cmdcapture"},{"id":"tmux.Plan.SplitPane","name":"SplitPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"SplitPaneRequest"}],"returns":"Ref"}],"doc":{"summary":"SplitPane records a split of the window or pane target names, and returns a [Ref] to the pane it will create.","body":"The returned ref can target later steps before the pane exists:\n\nplan := tmux.NewPlan()\npane := plan.SplitPane(window.Ref(), tmux.SplitPaneRequest{})\nplan.SendKeys(pane, tmux.SendKeysRequest{Command: tmux.Ptr(\"top\")})\nresult, err := plan.Run(ctx, server)"},"source":{"file":"tmux/plan_pane.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SplitPane","product":"core","slug":"tmux-plan-splitpane"},{"id":"tmux.Plan.SendKeys","name":"SendKeys","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"SendKeysRequest"}]}],"doc":{"summary":"SendKeys records keys sent to the pane target names.","body":"Sending keys produces no output and can share a dispatch; see [Plan.Explain].\n\nA request carrying a command records two steps, as [Pane.SendKeys] issues two\ntmux commands: the keys, and the Enter that submits them. Both are chainable,\nso they still travel together."},"source":{"file":"tmux/plan_pane.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SendKeys","product":"core","slug":"tmux-plan-sendkeys"},{"id":"tmux.Plan.DisplayMessage","name":"DisplayMessage","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"format","type":"string"}]}],"doc":{"summary":"DisplayMessage records a format expanded against the object target names, and returns its output in the step's [OpResult]. The zero [Ref] expands it against no object, the way [Plan.Cmd] takes one.","body":"It runs alone because command-list stdout has no operation boundaries."},"source":{"file":"tmux/plan_pane.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.DisplayMessage","product":"core","slug":"tmux-plan-displaymessage"},{"id":"tmux.Plan.KillPane","name":"KillPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillPane records the destruction of the pane target names."},"source":{"file":"tmux/plan_pane.go","line":85,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.KillPane","product":"core","slug":"tmux-plan-killpane"},{"id":"tmux.Plan.KillOtherPanes","name":"KillOtherPanes","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillOtherPanes records the destruction of every pane in the window holding the pane target names, except that pane."},"source":{"file":"tmux/plan_pane.go","line":97,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.KillOtherPanes","product":"core","slug":"tmux-plan-killotherpanes"},{"id":"tmux.Plan.SelectPane","name":"SelectPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"PaneSelectRequest"}]}],"doc":{"summary":"SelectPane records a selection or marking of the pane target names."},"source":{"file":"tmux/plan_pane.go","line":108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SelectPane","product":"core","slug":"tmux-plan-selectpane"},{"id":"tmux.Plan.ResizePane","name":"ResizePane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"ResizePaneRequest"}]}],"doc":{"summary":"ResizePane records a resize of the pane target names."},"source":{"file":"tmux/plan_pane.go","line":119,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.ResizePane","product":"core","slug":"tmux-plan-resizepane"},{"id":"tmux.Plan.SetPaneTitle","name":"SetPaneTitle","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"title","type":"string"}]}],"doc":{"summary":"SetPaneTitle records a title for the pane target names."},"source":{"file":"tmux/plan_pane.go","line":130,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SetPaneTitle","product":"core","slug":"tmux-plan-setpanetitle"},{"id":"tmux.Plan.ClearHistory","name":"ClearHistory","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"ClearHistoryRequest"}]}],"doc":{"summary":"ClearHistory records the clearing of the scrollback of the pane target names."},"source":{"file":"tmux/plan_pane.go","line":141,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.ClearHistory","product":"core","slug":"tmux-plan-clearhistory"},{"id":"tmux.Plan.SendPrefix","name":"SendPrefix","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"key","type":"PrefixKey"}]}],"doc":{"summary":"SendPrefix records tmux's prefix key sent to the pane target names."},"source":{"file":"tmux/plan_pane.go","line":154,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SendPrefix","product":"core","slug":"tmux-plan-sendprefix"},{"id":"tmux.Plan.PipePane","name":"PipePane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"PipePaneRequest"}]}],"doc":{"summary":"PipePane records the pane target names having its output piped to a shell command."},"source":{"file":"tmux/plan_pane.go","line":166,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.PipePane","product":"core","slug":"tmux-plan-pipepane"},{"id":"tmux.Plan.RespawnPane","name":"RespawnPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"RespawnRequest"}]}],"doc":{"summary":"RespawnPane records the pane target names being restarted with a new command."},"source":{"file":"tmux/plan_pane.go","line":177,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.RespawnPane","product":"core","slug":"tmux-plan-respawnpane"},{"id":"tmux.Plan.SwapPane","name":"SwapPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"detach","type":"bool"}]}],"doc":{"summary":"SwapPane records the panes target and source name exchanging places.","body":"Both panes are Refs so either may be created by an earlier step. Detach leaves\nactive selection alone; KeepZoom preserves a zoomed window."},"source":{"file":"tmux/plan_pane.go","line":191,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SwapPane","product":"core","slug":"tmux-plan-swappane"},{"id":"tmux.Plan.JoinPane","name":"JoinPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"horizontal","type":"bool"}]}],"doc":{"summary":"JoinPane records the pane source names being moved beside the pane target names, splitting that pane's space.","body":"Horizontal splits left and right; Detach leaves active selection alone."},"source":{"file":"tmux/plan_pane.go","line":216,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.JoinPane","product":"core","slug":"tmux-plan-joinpane"},{"id":"tmux.Plan.MovePane","name":"MovePane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"horizontal","type":"bool"}]}],"doc":{"summary":"MovePane records the pane source names being moved beside the pane target names without joining it to that pane's layout."},"source":{"file":"tmux/plan_pane.go","line":229,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.MovePane","product":"core","slug":"tmux-plan-movepane"},{"id":"tmux.Plan.StartServer","name":"StartServer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[]}],"doc":{"summary":"StartServer records the tmux server being started if it is not running."},"source":{"file":"tmux/plan_server.go","line":8,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.StartServer","product":"core","slug":"tmux-plan-startserver"},{"id":"tmux.Plan.SetOption","name":"SetOption","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"SetPlanOptionRequest"}]}],"doc":{"summary":"SetOption records a tmux option written on the object target names, or on the server when target is the zero [Ref] and Global is set.","body":"It takes the option's tmux name because typed accessors read values back."},"source":{"file":"tmux/plan_server.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SetOption","product":"core","slug":"tmux-plan-setoption"},{"id":"tmux.SetPlanOptionRequest","name":"SetPlanOptionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetPlanOptionRequest names one tmux option write for [Plan.SetOption]. Its zero value is invalid, because Name is required."},"source":{"file":"tmux/plan_server.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetPlanOptionRequest","product":"core","slug":"tmux-setplanoptionrequest"},{"id":"tmux.SetPlanOptionRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"string","doc":{"summary":"Name is the tmux option name, such as \"status\" or a user option \"@thing\"."},"source":{"file":"tmux/plan_server.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetPlanOptionRequest.Name","product":"core","slug":"tmux-setplanoptionrequest-name"},{"id":"tmux.SetPlanOptionRequest.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"string","doc":{"summary":"Value is the value to write. It is omitted when Unset is set."},"source":{"file":"tmux/plan_server.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetPlanOptionRequest.Value","product":"core","slug":"tmux-setplanoptionrequest-value"},{"id":"tmux.SetPlanOptionRequest.Global","name":"Global","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Global writes the server or global scope rather than the target's own."},"source":{"file":"tmux/plan_server.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetPlanOptionRequest.Global","product":"core","slug":"tmux-setplanoptionrequest-global"},{"id":"tmux.SetPlanOptionRequest.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Window writes a window option rather than a session or server one."},"source":{"file":"tmux/plan_server.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetPlanOptionRequest.Window","product":"core","slug":"tmux-setplanoptionrequest-window"},{"id":"tmux.SetPlanOptionRequest.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Pane writes a pane option."},"source":{"file":"tmux/plan_server.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetPlanOptionRequest.Pane","product":"core","slug":"tmux-setplanoptionrequest-pane"},{"id":"tmux.SetPlanOptionRequest.Unset","name":"Unset","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Unset removes the option instead of writing it."},"source":{"file":"tmux/plan_server.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetPlanOptionRequest.Unset","product":"core","slug":"tmux-setplanoptionrequest-unset"},{"id":"tmux.SetPlanOptionRequest.Append","name":"Append","kind":"attribute","modifiers":[],"parent":"tmux.SetPlanOptionRequest","signatures":[],"type":"bool","doc":{"summary":"Append adds to an existing value rather than replacing it."},"source":{"file":"tmux/plan_server.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetPlanOptionRequest.Append","product":"core","slug":"tmux-setplanoptionrequest-append"},{"id":"tmux.Plan.SetHook","name":"SetHook","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"},{"name":"global","type":"bool"}]}],"doc":{"summary":"SetHook records a tmux hook written on the object target names."},"source":{"file":"tmux/plan_server.go","line":96,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SetHook","product":"core","slug":"tmux-plan-sethook"},{"id":"tmux.Plan.SetBuffer","name":"SetBuffer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"name","type":"string"}]}],"doc":{"summary":"SetBuffer records text stored in a tmux buffer."},"source":{"file":"tmux/plan_server.go","line":119,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SetBuffer","product":"core","slug":"tmux-plan-setbuffer"},{"id":"tmux.Plan.DeleteBuffer","name":"DeleteBuffer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"name","type":"string"}]}],"doc":{"summary":"DeleteBuffer records a tmux buffer being removed. An empty name removes the most recently added buffer."},"source":{"file":"tmux/plan_server.go","line":134,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.DeleteBuffer","product":"core","slug":"tmux-plan-deletebuffer"},{"id":"tmux.Plan.DetachClient","name":"DetachClient","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"client","type":"ClientName"}]}],"doc":{"summary":"DetachClient records one client being detached. A client is named directly because plans do not create clients."},"source":{"file":"tmux/plan_server.go","line":149,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.DetachClient","product":"core","slug":"tmux-plan-detachclient"},{"id":"tmux.Plan.SuspendClient","name":"SuspendClient","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"client","type":"ClientName"}]}],"doc":{"summary":"SuspendClient records one client being suspended."},"source":{"file":"tmux/plan_server.go","line":160,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SuspendClient","product":"core","slug":"tmux-plan-suspendclient"},{"id":"tmux.Plan.RefreshClient","name":"RefreshClient","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"client","type":"ClientName"}]}],"doc":{"summary":"RefreshClient records one client being asked to redraw."},"source":{"file":"tmux/plan_server.go","line":171,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.RefreshClient","product":"core","slug":"tmux-plan-refreshclient"},{"id":"tmux.Plan.SwitchClient","name":"SwitchClient","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"client","type":"ClientName"}]}],"doc":{"summary":"SwitchClient records one client being moved to the session target names. target may refer to a session an earlier step creates."},"source":{"file":"tmux/plan_server.go","line":183,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SwitchClient","product":"core","slug":"tmux-plan-switchclient"},{"id":"tmux.Plan.LockServer","name":"LockServer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[]}],"doc":{"summary":"LockServer records every client attached to the server being locked."},"source":{"file":"tmux/plan_server.go","line":194,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.LockServer","product":"core","slug":"tmux-plan-lockserver"},{"id":"tmux.Plan.NewSession","name":"NewSession","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"request","type":"NewSessionRequest"}],"returns":"Ref"}],"doc":{"summary":"NewSession records a detached session and returns a [Ref] to it.","body":"KillExisting is rejected: [Server.NewSession] probes for the named session\nand removes it before creating, and a plan records without reading. Record\n[Plan.KillSession] before this instead, which says the same thing in the\norder it happens."},"source":{"file":"tmux/plan_session.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.NewSession","product":"core","slug":"tmux-plan-newsession"},{"id":"tmux.Plan.KillSession","name":"KillSession","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillSession records the destruction of the session target names."},"source":{"file":"tmux/plan_session.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.KillSession","product":"core","slug":"tmux-plan-killsession"},{"id":"tmux.Plan.RenameSession","name":"RenameSession","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"}]}],"doc":{"summary":"RenameSession records a new name for the session target names."},"source":{"file":"tmux/plan_session.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.RenameSession","product":"core","slug":"tmux-plan-renamesession"},{"id":"tmux.Plan.NextWindow","name":"NextWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"NextWindow records the session target names moving to its next window."},"source":{"file":"tmux/plan_session.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.NextWindow","product":"core","slug":"tmux-plan-nextwindow"},{"id":"tmux.Plan.PreviousWindow","name":"PreviousWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"PreviousWindow records the session target names moving to its previous window."},"source":{"file":"tmux/plan_session.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.PreviousWindow","product":"core","slug":"tmux-plan-previouswindow"},{"id":"tmux.Plan.LastWindow","name":"LastWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"LastWindow records the session target names returning to its previously current window."},"source":{"file":"tmux/plan_session.go","line":81,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.LastWindow","product":"core","slug":"tmux-plan-lastwindow"},{"id":"tmux.Plan.LockSession","name":"LockSession","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"LockSession records every client attached to the session target names being locked."},"source":{"file":"tmux/plan_session.go","line":93,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.LockSession","product":"core","slug":"tmux-plan-locksession"},{"id":"tmux.Plan.DetachClients","name":"DetachClients","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"DetachClients records every client attached to the session target names being detached."},"source":{"file":"tmux/plan_session.go","line":105,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.DetachClients","product":"core","slug":"tmux-plan-detachclients"},{"id":"tmux.Plan.SetEnvironment","name":"SetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"}]}],"doc":{"summary":"SetEnvironment records a variable set in the session target names, or in the server when target is the zero [Ref]."},"source":{"file":"tmux/plan_session.go","line":120,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SetEnvironment","product":"core","slug":"tmux-plan-setenvironment"},{"id":"tmux.Plan.UnsetEnvironment","name":"UnsetEnvironment","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"}]}],"doc":{"summary":"UnsetEnvironment records a variable removed from the session target names, or from the server when target is the zero [Ref]."},"source":{"file":"tmux/plan_session.go","line":138,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.UnsetEnvironment","product":"core","slug":"tmux-plan-unsetenvironment"},{"id":"tmux.Plan.SourceFile","name":"SourceFile","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"request","type":"SourceFileRequest"}]}],"doc":{"summary":"SourceFile records a tmux configuration file being loaded."},"source":{"file":"tmux/plan_session.go","line":152,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SourceFile","product":"core","slug":"tmux-plan-sourcefile"},{"id":"tmux.Plan.KillServer","name":"KillServer","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[]}],"doc":{"summary":"KillServer records the tmux server being shut down. Nothing recorded after it can run because the server will be gone."},"source":{"file":"tmux/plan_session.go","line":164,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.KillServer","product":"core","slug":"tmux-plan-killserver"},{"id":"tmux.Plan.NewWindow","name":"NewWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"NewWindowRequest"}],"returns":"Ref"}],"doc":{"summary":"NewWindow records a window created in the session or beside the window that target names, and returns a [Ref] to it.","body":"SelectExisting is rejected: it asks tmux for an existing window's\nexpanded name before creating anything, and a plan records without reading."},"source":{"file":"tmux/plan_window.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.NewWindow","product":"core","slug":"tmux-plan-newwindow"},{"id":"tmux.Plan.KillWindow","name":"KillWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillWindow records the destruction of the window target names."},"source":{"file":"tmux/plan_window.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.KillWindow","product":"core","slug":"tmux-plan-killwindow"},{"id":"tmux.Plan.KillOtherWindows","name":"KillOtherWindows","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"KillOtherWindows records the destruction of every window in the session holding the window target names, except that window."},"source":{"file":"tmux/plan_window.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.KillOtherWindows","product":"core","slug":"tmux-plan-killotherwindows"},{"id":"tmux.Plan.RenameWindow","name":"RenameWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"name","type":"string"}]}],"doc":{"summary":"RenameWindow records a new name for the window target names."},"source":{"file":"tmux/plan_window.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.RenameWindow","product":"core","slug":"tmux-plan-renamewindow"},{"id":"tmux.Plan.SelectWindow","name":"SelectWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"SelectWindow records the window target names becoming its session's current window."},"source":{"file":"tmux/plan_window.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SelectWindow","product":"core","slug":"tmux-plan-selectwindow"},{"id":"tmux.Plan.SelectLayout","name":"SelectLayout","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"SelectLayoutRequest"}]}],"doc":{"summary":"SelectLayout records a layout applied to the window target names. Run checks every recorded layout before dispatching any operation. Recording and Preview perform no I/O; Preview uses its supplied version for name support."},"source":{"file":"tmux/plan_window.go","line":84,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SelectLayout","product":"core","slug":"tmux-plan-selectlayout"},{"id":"tmux.Plan.NextLayout","name":"NextLayout","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"NextLayout records the next preset layout applied to the window target names."},"source":{"file":"tmux/plan_window.go","line":96,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.NextLayout","product":"core","slug":"tmux-plan-nextlayout"},{"id":"tmux.Plan.PreviousLayout","name":"PreviousLayout","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"PreviousLayout records the previous preset layout applied to the window target names."},"source":{"file":"tmux/plan_window.go","line":108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.PreviousLayout","product":"core","slug":"tmux-plan-previouslayout"},{"id":"tmux.Plan.ResizeWindow","name":"ResizeWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"ResizeWindowRequest"}]}],"doc":{"summary":"ResizeWindow records a resize of the window target names."},"source":{"file":"tmux/plan_window.go","line":119,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.ResizeWindow","product":"core","slug":"tmux-plan-resizewindow"},{"id":"tmux.Plan.RotateWindow","name":"RotateWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"RotateWindowRequest"}]}],"doc":{"summary":"RotateWindow records the panes of the window target names being rotated through their positions."},"source":{"file":"tmux/plan_window.go","line":131,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.RotateWindow","product":"core","slug":"tmux-plan-rotatewindow"},{"id":"tmux.Plan.RespawnWindow","name":"RespawnWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"RespawnRequest"}]}],"doc":{"summary":"RespawnWindow records the window target names being restarted with a new command."},"source":{"file":"tmux/plan_window.go","line":143,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.RespawnWindow","product":"core","slug":"tmux-plan-respawnwindow"},{"id":"tmux.Plan.LastPane","name":"LastPane","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"}]}],"doc":{"summary":"LastPane records the window target names returning to its previously active pane."},"source":{"file":"tmux/plan_window.go","line":155,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.LastPane","product":"core","slug":"tmux-plan-lastpane"},{"id":"tmux.Plan.LinkWindow","name":"LinkWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"LinkWindowRequest"}]}],"doc":{"summary":"LinkWindow records the window source names being linked into the session target names.","body":"target supplies the destination session so it may refer to a session an\nearlier step creates. TargetIndex still selects the position within it."},"source":{"file":"tmux/plan_window.go","line":170,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.LinkWindow","product":"core","slug":"tmux-plan-linkwindow"},{"id":"tmux.Plan.UnlinkWindow","name":"UnlinkWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"UnlinkWindowRequest"}]}],"doc":{"summary":"UnlinkWindow records the window target names being removed from the session it is linked into."},"source":{"file":"tmux/plan_window.go","line":183,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.UnlinkWindow","product":"core","slug":"tmux-plan-unlinkwindow"},{"id":"tmux.Plan.MoveWindow","name":"MoveWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"request","type":"MoveWindowRequest"}]}],"doc":{"summary":"MoveWindow records the window source names being moved into the session target names.","body":"target supplies the destination session. TargetIndex selects its position."},"source":{"file":"tmux/plan_window.go","line":201,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.MoveWindow","product":"core","slug":"tmux-plan-movewindow"},{"id":"tmux.Plan.SwapWindow","name":"SwapWindow","kind":"method","modifiers":[],"parent":"tmux.Plan","signatures":[{"params":[{"name":"target","type":"Ref"},{"name":"detach","type":"bool"}]}],"doc":{"summary":"SwapWindow records the windows target and source name exchanging places. Detach leaves each session's current window unchanged."},"source":{"file":"tmux/plan_window.go","line":214,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Plan.SwapWindow","product":"core","slug":"tmux-plan-swapwindow"},{"id":"tmux.ErrPollCondition","name":"ErrPollCondition","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrPollCondition identifies a poll whose condition was nil. It is matched by errors.Is."},"source":{"file":"tmux/poll.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrPollCondition","product":"core","slug":"tmux-errpollcondition"},{"id":"tmux.Poll","name":"Poll","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"interval","type":"time.Duration"},{"name":"condition","type":"func(context.Context) (bool, error)"}],"returns":"error"}],"doc":{"summary":"Poll checks condition immediately and then after each interval, until it reports true, returns an error, or ctx ends.","body":"A condition receives ctx and must observe cancellation itself; Poll cannot\ninterrupt one already running. Poll returns condition errors unchanged and\nctx.Err when ctx ends first.\n\nPoll is for a state tmux does not announce. Waiting for a pane to print\nsomething is not one: [PaneObservation.WaitFor] is woken by tmux as the\npane writes, where a poll re-reads the screen on a guess and can match a\nshell's echo of what was typed. [Server.WaitFor] waits on tmux's separate\nwait-for channel."},"source":{"file":"tmux/poll.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Poll","product":"core","slug":"tmux-poll"},{"id":"tmux.PromptType","name":"PromptType","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PromptType selects one closed tmux prompt-history class. The zero value selects all prompt types."},"source":{"file":"tmux/prompt_history.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptType","product":"core","slug":"tmux-prompttype"},{"id":"tmux.PromptTypeAll","name":"PromptTypeAll","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeAll selects every prompt-history class and omits -T."},"source":{"file":"tmux/prompt_history.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptTypeAll","product":"core","slug":"tmux-prompttypeall"},{"id":"tmux.PromptTypeCommand","name":"PromptTypeCommand","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeCommand selects command-prompt history."},"source":{"file":"tmux/prompt_history.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptTypeCommand","product":"core","slug":"tmux-prompttypecommand"},{"id":"tmux.PromptTypeSearch","name":"PromptTypeSearch","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeSearch selects search-prompt history."},"source":{"file":"tmux/prompt_history.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptTypeSearch","product":"core","slug":"tmux-prompttypesearch"},{"id":"tmux.PromptTypeTarget","name":"PromptTypeTarget","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeTarget selects target-prompt history."},"source":{"file":"tmux/prompt_history.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptTypeTarget","product":"core","slug":"tmux-prompttypetarget"},{"id":"tmux.PromptTypeWindowTarget","name":"PromptTypeWindowTarget","kind":"constant","modifiers":[],"signatures":[],"type":"PromptType","doc":{"summary":"PromptTypeWindowTarget selects window-target-prompt history."},"source":{"file":"tmux/prompt_history.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptTypeWindowTarget","product":"core","slug":"tmux-prompttypewindowtarget"},{"id":"tmux.PromptHistoryRequest","name":"PromptHistoryRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PromptHistoryRequest selects one prompt-history class. A zero request selects every class."},"source":{"file":"tmux/prompt_history.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptHistoryRequest","product":"core","slug":"tmux-prompthistoryrequest"},{"id":"tmux.PromptHistoryRequest.Type","name":"Type","kind":"attribute","modifiers":[],"parent":"tmux.PromptHistoryRequest","signatures":[],"type":"PromptType","doc":{"summary":"Type selects a prompt-history class; zero selects all classes."},"source":{"file":"tmux/prompt_history.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PromptHistoryRequest.Type","product":"core","slug":"tmux-prompthistoryrequest-type"},{"id":"tmux.Server.ShowPromptHistory","name":"ShowPromptHistory","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PromptHistoryRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ShowPromptHistory returns an owned snapshot of tmux prompt-history lines. It requires tmux 3.3 or later and returns [VersionTooLowError] below that floor. A tmux command or transport failure is returned rather than answered with no history."},"source":{"file":"tmux/prompt_history.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ShowPromptHistory","product":"core","slug":"tmux-server-showprompthistory"},{"id":"tmux.Server.ClearPromptHistory","name":"ClearPromptHistory","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PromptHistoryRequest"}],"returns":"error"}],"doc":{"summary":"ClearPromptHistory clears all tmux prompt history or one selected class. Version, transport, and completed-stderr failures are returned. It requires tmux 3.3 or later and returns [VersionTooLowError] below that floor."},"source":{"file":"tmux/prompt_history.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ClearPromptHistory","product":"core","slug":"tmux-server-clearprompthistory"},{"id":"tmux.Session.ActiveWindow","name":"ActiveWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(Window, bool)"}],"doc":{"summary":"ActiveWindow returns this session's sole active winlink from the materialized snapshot. It never queries tmux; use [Session.ResolveActiveWindow] for live state."},"source":{"file":"tmux/relations.go","line":11,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ActiveWindow","product":"core","slug":"tmux-session-activewindow"},{"id":"tmux.Session.ActivePane","name":"ActivePane","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[],"returns":"(Pane, bool)"}],"doc":{"summary":"ActivePane returns the active pane in this session's materialized active window. It never queries tmux; use [Session.ResolveActivePane] for live state."},"source":{"file":"tmux/relations.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ActivePane","product":"core","slug":"tmux-session-activepane"},{"id":"tmux.Window.ActivePane","name":"ActivePane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"(Pane, bool)"}],"doc":{"summary":"ActivePane returns the first active pane in this materialized winlink view. It never queries tmux; use [Window.ResolveActivePane] for live state."},"source":{"file":"tmux/relations.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ActivePane","product":"core","slug":"tmux-window-activepane"},{"id":"tmux.Window.LinkedSessions","name":"LinkedSessions","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[],"returns":"([]Session, bool)"}],"doc":{"summary":"LinkedSessions returns newly allocated shallow copies of materialized sessions containing this window, and reports whether the receiver carries relations at all. It never queries tmux."},"source":{"file":"tmux/relations.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.LinkedSessions","product":"core","slug":"tmux-window-linkedsessions"},{"id":"tmux.Session.ResolveActiveWindow","name":"ResolveActiveWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"ResolveActiveWindow snapshots live tmux state and returns this session's sole exact active winlink. It returns [SnapshotLookupError] cardinality errors."},"source":{"file":"tmux/relations.go","line":83,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ResolveActiveWindow","product":"core","slug":"tmux-session-resolveactivewindow"},{"id":"tmux.Session.ResolveActivePane","name":"ResolveActivePane","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Pane, error)"}],"doc":{"summary":"ResolveActivePane returns the active pane in this session's active window, read live. It lists that session's panes rather than taking a whole-server snapshot, because a pane row already carries which window is active. It returns [SnapshotLookupError] cardinality errors, which match [ErrNotFound] when nothing was found."},"source":{"file":"tmux/relations.go","line":96,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.ResolveActivePane","product":"core","slug":"tmux-session-resolveactivepane"},{"id":"tmux.Window.ResolveSession","name":"ResolveSession","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Session, error)"}],"doc":{"summary":"ResolveSession snapshots live tmux state and returns this exact winlink's parent session. It returns [SnapshotLookupError] cardinality errors."},"source":{"file":"tmux/relations.go","line":139,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ResolveSession","product":"core","slug":"tmux-window-resolvesession"},{"id":"tmux.Window.ResolveActivePane","name":"ResolveActivePane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Pane, error)"}],"doc":{"summary":"ResolveActivePane returns the active pane in this exact winlink view, read live. It lists that window's panes rather than taking a whole-server snapshot. It returns [SnapshotLookupError] cardinality errors, which match [ErrNotFound] when nothing was found."},"source":{"file":"tmux/relations.go","line":156,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.ResolveActivePane","product":"core","slug":"tmux-window-resolveactivepane"},{"id":"tmux.Pane.ResolveWindow","name":"ResolveWindow","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"ResolveWindow snapshots live tmux state and returns the exact winlink containing this pane view. It returns [SnapshotLookupError] cardinality errors."},"source":{"file":"tmux/relations.go","line":175,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ResolveWindow","product":"core","slug":"tmux-pane-resolvewindow"},{"id":"tmux.Pane.ResolveSession","name":"ResolveSession","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Session, error)"}],"doc":{"summary":"ResolveSession snapshots live tmux state and returns the parent session of this pane's exact winlink. It returns [SnapshotLookupError] cardinality errors."},"source":{"file":"tmux/relations.go","line":185,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.ResolveSession","product":"core","slug":"tmux-pane-resolvesession"},{"id":"tmux.ErrMissingSubcommand","name":"ErrMissingSubcommand","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMissingSubcommand identifies an object command with no tmux subcommand."},"source":{"file":"tmux/scoped_command.go","line":9,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrMissingSubcommand","product":"core","slug":"tmux-errmissingsubcommand"},{"id":"tmux.Session.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(CommandResult, error)"}],"doc":{"summary":"Cmd executes a tmux subcommand targeted to the session's stable ID."},"source":{"file":"tmux/scoped_command.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Cmd","product":"core","slug":"tmux-session-cmd"},{"id":"tmux.Window.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(CommandResult, error)"}],"doc":{"summary":"Cmd executes a tmux subcommand targeted to the window's stable ID."},"source":{"file":"tmux/scoped_command.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Cmd","product":"core","slug":"tmux-window-cmd"},{"id":"tmux.Pane.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(CommandResult, error)"}],"doc":{"summary":"Cmd executes a tmux subcommand targeted to the pane's stable ID."},"source":{"file":"tmux/scoped_command.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Cmd","product":"core","slug":"tmux-pane-cmd"},{"id":"tmux.Server.SearchSessions","name":"SearchSessions","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Session, error)"}],"doc":{"summary":"SearchSessions returns a newly materialized snapshot projection of sessions selected by tmux's live -f expression. A nil filter omits -f; a nonnil empty filter remains an explicit empty expression."},"source":{"file":"tmux/search.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SearchSessions","product":"core","slug":"tmux-server-searchsessions"},{"id":"tmux.Server.SearchClients","name":"SearchClients","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Client, error)"}],"doc":{"summary":"SearchClients returns a newly materialized snapshot projection of clients selected by tmux's live -f expression. A nil filter omits -f and requests the unfiltered listing on every supported tmux version. A nonnil filter, including an empty expression, requires tmux 3.4 or newer and otherwise returns [VersionTooLowError]."},"source":{"file":"tmux/search.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SearchClients","product":"core","slug":"tmux-server-searchclients"},{"id":"tmux.Server.SearchWindows","name":"SearchWindows","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Window, error)"}],"doc":{"summary":"SearchWindows returns a newly materialized snapshot projection of winlinks selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression."},"source":{"file":"tmux/search.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SearchWindows","product":"core","slug":"tmux-server-searchwindows"},{"id":"tmux.Server.SearchPanes","name":"SearchPanes","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Pane, error)"}],"doc":{"summary":"SearchPanes returns a newly materialized snapshot projection of pane views selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression."},"source":{"file":"tmux/search.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SearchPanes","product":"core","slug":"tmux-server-searchpanes"},{"id":"tmux.Session.SearchWindows","name":"SearchWindows","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Window, error)"}],"doc":{"summary":"SearchWindows returns this session's winlinks selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression. The session's stable identity limits the projection."},"source":{"file":"tmux/search.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SearchWindows","product":"core","slug":"tmux-session-searchwindows"},{"id":"tmux.Session.SearchPanes","name":"SearchPanes","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Pane, error)"}],"doc":{"summary":"SearchPanes returns this session's pane views selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression. The session's stable identity limits the projection."},"source":{"file":"tmux/search.go","line":117,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SearchPanes","product":"core","slug":"tmux-session-searchpanes"},{"id":"tmux.Window.SearchPanes","name":"SearchPanes","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"filter","type":"*TmuxFilter"}],"returns":"([]Pane, error)"}],"doc":{"summary":"SearchPanes returns this window's pane views selected by tmux's live -f expression. A nil filter omits -f and a nonnil empty filter sends an explicit expression. Stable session and window identities limit the projection."},"source":{"file":"tmux/search.go","line":144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SearchPanes","product":"core","slug":"tmux-window-searchpanes"},{"id":"tmux.Server","name":"Server","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Server is an immutable handle to one tmux configuration. Its zero value is invalid. Copying a configured Server preserves its configuration and shares version-cache coordination; only the documented concurrent operations are safe to share."},"source":{"file":"tmux/server.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server","product":"core","slug":"tmux-server"},{"id":"tmux.Server.SocketPath","name":"SocketPath","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"SocketPath returns the absolute socket path selected when the server was constructed. An invalid server returns an empty string."},"source":{"file":"tmux/server.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SocketPath","product":"core","slug":"tmux-server-socketpath"},{"id":"tmux.Server.ConfigFile","name":"ConfigFile","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"ConfigFile returns the configured tmux configuration path."},"source":{"file":"tmux/server.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ConfigFile","product":"core","slug":"tmux-server-configfile"},{"id":"tmux.Server.ProcessEnvironment","name":"ProcessEnvironment","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"[]string"}],"doc":{"summary":"ProcessEnvironment returns the normalized environment explicitly supplied through [ServerOptions]. Nil means the server inherited a private process snapshot. The returned slice is owned by the caller; an invalid server returns nil."},"source":{"file":"tmux/server.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ProcessEnvironment","product":"core","slug":"tmux-server-processenvironment"},{"id":"tmux.Server.Executable","name":"Executable","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Executable returns the absolute tmux executable path resolved when the server was constructed. An invalid server returns an empty string."},"source":{"file":"tmux/server.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Executable","product":"core","slug":"tmux-server-executable"},{"id":"tmux.Server.Cmd","name":"Cmd","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"args","type":"string"}],"returns":"(CommandResult, error)"}],"doc":{"summary":"Cmd executes raw tmux arguments and returns caller-owned result slices. A completed nonzero exit remains a result; validation and transport failures return errors. Cancellation cannot prove whether a mutation reached tmux.","body":"An argument that is exactly \";\" separates two tmux commands, so one call can\nsubmit a command list. tmux runs a list until a command fails and drops the\nrest, and answers with one merged stdout, so a caller that needs to know\nwhich command produced which line submits them separately. A list means the\nsame thing through either execution binding.\n\nOnly a standalone \";\" separates commands. Other semicolons follow the selected\nbinding's parsing; typed operations keep values literal across bindings."},"source":{"file":"tmux/server.go","line":99,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Cmd","product":"core","slug":"tmux-server-cmd"},{"id":"tmux.Server.IsAlive","name":"IsAlive","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(bool, error)"}],"doc":{"summary":"IsAlive reports whether a tmux server answers on the configured socket. Only an absent server reports false without an error: a socket that exists but cannot be reached, such as one the process may not read, is a question that could not be answered and is returned as an error. Use [Server.CheckAlive] where an absent server is itself the failure."},"source":{"file":"tmux/server.go","line":145,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.IsAlive","product":"core","slug":"tmux-server-isalive"},{"id":"tmux.Server.CheckAlive","name":"CheckAlive","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CheckAlive returns a [CommandError] when the configured server is not alive. Cancellation and transport failures are returned directly. Use [Server.IsAlive] where an absent server is an answer rather than a failure."},"source":{"file":"tmux/server.go","line":164,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.CheckAlive","product":"core","slug":"tmux-server-checkalive"},{"id":"tmux.AttachSessionOptions","name":"AttachSessionOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"AttachSessionOptions configures terminal ownership and attach behavior shared by server- and session-scoped attachment. Nil StartDirectory omits its flag and a nonnil empty string is explicit; ClientFlags is copied. The Stdin, Stdout, and Stderr pointers are retained for the attach call and are never owned or closed by this package."},"source":{"file":"tmux/server_attach.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions","product":"core","slug":"tmux-attachsessionoptions"},{"id":"tmux.AttachSessionOptions.DetachOthers","name":"DetachOthers","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"bool","doc":{"summary":"DetachOthers disconnects other clients attached to the target session."},"source":{"file":"tmux/server_attach.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.DetachOthers","product":"core","slug":"tmux-attachsessionoptions-detachothers"},{"id":"tmux.AttachSessionOptions.DetachParent","name":"DetachParent","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"bool","doc":{"summary":"DetachParent detaches the invoking client from its parent session first."},"source":{"file":"tmux/server_attach.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.DetachParent","product":"core","slug":"tmux-attachsessionoptions-detachparent"},{"id":"tmux.AttachSessionOptions.NoUpdateEnvironment","name":"NoUpdateEnvironment","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"bool","doc":{"summary":"NoUpdateEnvironment preserves the invoking client's environment."},"source":{"file":"tmux/server_attach.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.NoUpdateEnvironment","product":"core","slug":"tmux-attachsessionoptions-noupdateenvironment"},{"id":"tmux.AttachSessionOptions.ReadOnly","name":"ReadOnly","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"bool","doc":{"summary":"ReadOnly attaches the client with read-only permissions."},"source":{"file":"tmux/server_attach.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.ReadOnly","product":"core","slug":"tmux-attachsessionoptions-readonly"},{"id":"tmux.AttachSessionOptions.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"*string","doc":{"summary":"StartDirectory selects the attached client's initial directory."},"source":{"file":"tmux/server_attach.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.StartDirectory","product":"core","slug":"tmux-attachsessionoptions-startdirectory"},{"id":"tmux.AttachSessionOptions.ClientFlags","name":"ClientFlags","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"[]string","doc":{"summary":"ClientFlags are comma-joined client flags copied before attachment starts."},"source":{"file":"tmux/server_attach.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.ClientFlags","product":"core","slug":"tmux-attachsessionoptions-clientflags"},{"id":"tmux.AttachSessionOptions.Stdin","name":"Stdin","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"*os.File","doc":{"summary":"Stdin is the attached tmux client's input stream; nil inherits process stdin."},"source":{"file":"tmux/server_attach.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.Stdin","product":"core","slug":"tmux-attachsessionoptions-stdin"},{"id":"tmux.AttachSessionOptions.Stdout","name":"Stdout","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"*os.File","doc":{"summary":"Stdout is the attached tmux client's output stream; nil inherits process stdout."},"source":{"file":"tmux/server_attach.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.Stdout","product":"core","slug":"tmux-attachsessionoptions-stdout"},{"id":"tmux.AttachSessionOptions.Stderr","name":"Stderr","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionOptions","signatures":[],"type":"*os.File","doc":{"summary":"Stderr is the attached tmux client's error stream; nil inherits process stderr."},"source":{"file":"tmux/server_attach.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionOptions.Stderr","product":"core","slug":"tmux-attachsessionoptions-stderr"},{"id":"tmux.AttachSessionRequest","name":"AttachSessionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"AttachSessionRequest selects a session name or tmux target pattern and configures a blocking terminal attachment. An empty Target lets tmux choose."},"source":{"file":"tmux/server_attach.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionRequest","product":"core","slug":"tmux-attachsessionrequest"},{"id":"tmux.AttachSessionRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.AttachSessionRequest","signatures":[],"type":"string","doc":{"summary":"Target is a session name or tmux target pattern; empty leaves selection to tmux."},"source":{"file":"tmux/server_attach.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.AttachSessionRequest.Target","product":"core","slug":"tmux-attachsessionrequest-target"},{"id":"tmux.Server.Start","name":"Start","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Start starts the configured tmux server. It is idempotent when that server is already running. Completed stderr is an error; cancellation does not prove that a daemon was not started.","body":"With tmux's exit-empty default, a server holding no sessions may exit before\nthe next command even though Start succeeded. Create a session or disable\nexit-empty in [ServerOptions.ConfigFile] before startup. Use [Server.IsAlive]\nor [Server.CheckAlive] to check it."},"source":{"file":"tmux/server_attach.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Start","product":"core","slug":"tmux-server-start"},{"id":"tmux.Server.AttachSession","name":"AttachSession","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"AttachSessionRequest"}],"returns":"error"}],"doc":{"summary":"AttachSession attaches the caller's terminal to a matching session and blocks until detach or context cancellation. Nil standard streams inherit the process streams; each stream must be a concrete terminal descriptor. The call retains caller-supplied files while attached and never owns or closes them. A completed nonzero exit returns [CommandError]; cancellation can end waiting but does not prove that attachment or detachment did not occur. On Unix, cancellation requests a tmux disconnect before bounded forced cleanup. If the daemon cannot respond, callers may need to restore their terminal state after the call returns.","body":"Alone among this package's operations, it leaves tmux's own locale detection\nalone, because what tmux writes here reaches the caller's terminal rather\nthan this package. See [Session.Attach] for the session-scoped form."},"source":{"file":"tmux/server_attach.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.AttachSession","product":"core","slug":"tmux-server-attachsession"},{"id":"tmux.Session.Attach","name":"Attach","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"options","type":"AttachSessionOptions"}],"returns":"error"}],"doc":{"summary":"Attach attaches the caller's terminal to this session's stable identifier and blocks until detach or context cancellation. It validates the receiver's stable SessionID, retains but never closes caller-supplied streams, and returns [CommandError] for a completed nonzero exit. Cancellation does not prove attachment or detachment did not occur. See [Server.AttachSession] for locale handling and terminal recovery after forced cancellation."},"source":{"file":"tmux/server_attach.go","line":102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Attach","product":"core","slug":"tmux-session-attach"},{"id":"tmux.TmuxFilter","name":"TmuxFilter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TmuxFilter is a raw tmux -f format expression. It is distinct from the generated local filter structs and is evaluated only by tmux. A nil filter omits -f; a nonnil empty filter sends an explicit empty expression.","body":"The expression is tmux's own, so it is written the way tmux's FORMATS\nsection describes rather than built from Go values:\n\nactive := tmux.TmuxFilter(\"#{==:#{window_active},1}\")\nwindows, err := session.SearchWindows(ctx, &active)\n\ntmux evaluates this while listing. Generated model filters run in Go after\nmaterialization.\n\nrevive:disable-next-line:exported TmuxFilter preserves tmux vocabulary beside local model filters."},"source":{"file":"tmux/server_buffers.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TmuxFilter","product":"core","slug":"tmux-tmuxfilter"},{"id":"tmux.SetBufferRequest","name":"SetBufferRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SetBufferRequest configures storing data in a tmux paste buffer. Its zero value writes an empty most-recent buffer; nil Name selects that buffer while a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetBufferRequest","product":"core","slug":"tmux-setbufferrequest"},{"id":"tmux.SetBufferRequest.Data","name":"Data","kind":"attribute","modifiers":[],"parent":"tmux.SetBufferRequest","signatures":[],"type":"string","doc":{"summary":"Data is the exact buffer data to store or append."},"source":{"file":"tmux/server_buffers.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetBufferRequest.Data","product":"core","slug":"tmux-setbufferrequest-data"},{"id":"tmux.SetBufferRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SetBufferRequest","signatures":[],"type":"*string","doc":{"summary":"Name selects a named buffer, or nil for tmux's most-recent buffer."},"source":{"file":"tmux/server_buffers.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetBufferRequest.Name","product":"core","slug":"tmux-setbufferrequest-name"},{"id":"tmux.SetBufferRequest.Append","name":"Append","kind":"attribute","modifiers":[],"parent":"tmux.SetBufferRequest","signatures":[],"type":"bool","doc":{"summary":"Append appends Data instead of replacing the selected buffer."},"source":{"file":"tmux/server_buffers.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SetBufferRequest.Append","product":"core","slug":"tmux-setbufferrequest-append"},{"id":"tmux.SaveBufferRequest","name":"SaveBufferRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SaveBufferRequest configures writing a tmux paste buffer to a file. Its zero value is invalid because Path is required; nil Name selects the most-recent buffer and a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SaveBufferRequest","product":"core","slug":"tmux-savebufferrequest"},{"id":"tmux.SaveBufferRequest.Path","name":"Path","kind":"attribute","modifiers":[],"parent":"tmux.SaveBufferRequest","signatures":[],"type":"string","doc":{"summary":"Path is the required output file path."},"source":{"file":"tmux/server_buffers.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SaveBufferRequest.Path","product":"core","slug":"tmux-savebufferrequest-path"},{"id":"tmux.SaveBufferRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SaveBufferRequest","signatures":[],"type":"*string","doc":{"summary":"Name selects a named buffer, or nil for tmux's most-recent buffer."},"source":{"file":"tmux/server_buffers.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SaveBufferRequest.Name","product":"core","slug":"tmux-savebufferrequest-name"},{"id":"tmux.SaveBufferRequest.Append","name":"Append","kind":"attribute","modifiers":[],"parent":"tmux.SaveBufferRequest","signatures":[],"type":"bool","doc":{"summary":"Append appends buffer data to Path instead of replacing its contents."},"source":{"file":"tmux/server_buffers.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SaveBufferRequest.Append","product":"core","slug":"tmux-savebufferrequest-append"},{"id":"tmux.LoadBufferRequest","name":"LoadBufferRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"LoadBufferRequest configures loading a file into a tmux paste buffer. Its zero value is invalid because Path is required; nil Name lets tmux allocate a buffer and a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LoadBufferRequest","product":"core","slug":"tmux-loadbufferrequest"},{"id":"tmux.LoadBufferRequest.Path","name":"Path","kind":"attribute","modifiers":[],"parent":"tmux.LoadBufferRequest","signatures":[],"type":"string","doc":{"summary":"Path is the required input file path."},"source":{"file":"tmux/server_buffers.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LoadBufferRequest.Path","product":"core","slug":"tmux-loadbufferrequest-path"},{"id":"tmux.LoadBufferRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.LoadBufferRequest","signatures":[],"type":"*string","doc":{"summary":"Name selects the destination buffer, or nil for tmux's allocation behavior."},"source":{"file":"tmux/server_buffers.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LoadBufferRequest.Name","product":"core","slug":"tmux-loadbufferrequest-name"},{"id":"tmux.LoadBufferFromOptions","name":"LoadBufferFromOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"LoadBufferFromOptions configures streaming data into a tmux paste buffer. Its zero value lets tmux allocate a buffer; nil Name selects that allocation and a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LoadBufferFromOptions","product":"core","slug":"tmux-loadbufferfromoptions"},{"id":"tmux.LoadBufferFromOptions.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.LoadBufferFromOptions","signatures":[],"type":"*string","doc":{"summary":"Name selects the destination buffer, or nil for tmux's allocation behavior."},"source":{"file":"tmux/server_buffers.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LoadBufferFromOptions.Name","product":"core","slug":"tmux-loadbufferfromoptions-name"},{"id":"tmux.SaveBufferToOptions","name":"SaveBufferToOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SaveBufferToOptions configures streaming a tmux paste buffer's contents out. Its zero value selects tmux's most-recent buffer; a pointer to an empty name is explicit."},"source":{"file":"tmux/server_buffers.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SaveBufferToOptions","product":"core","slug":"tmux-savebuffertooptions"},{"id":"tmux.SaveBufferToOptions.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.SaveBufferToOptions","signatures":[],"type":"*string","doc":{"summary":"Name selects a named buffer, or nil for tmux's most-recent buffer."},"source":{"file":"tmux/server_buffers.go","line":73,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SaveBufferToOptions.Name","product":"core","slug":"tmux-savebuffertooptions-name"},{"id":"tmux.ListBuffersRequest","name":"ListBuffersRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ListBuffersRequest configures tmux's live paste-buffer listing. Its zero value requests tmux's default output; nil Format and Filter omit their flags, whereas pointers to empty strings are explicit expressions."},"source":{"file":"tmux/server_buffers.go","line":79,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ListBuffersRequest","product":"core","slug":"tmux-listbuffersrequest"},{"id":"tmux.ListBuffersRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.ListBuffersRequest","signatures":[],"type":"*string","doc":{"summary":"Format selects tmux's output format."},"source":{"file":"tmux/server_buffers.go","line":81,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ListBuffersRequest.Format","product":"core","slug":"tmux-listbuffersrequest-format"},{"id":"tmux.ListBuffersRequest.Filter","name":"Filter","kind":"attribute","modifiers":[],"parent":"tmux.ListBuffersRequest","signatures":[],"type":"*TmuxFilter","doc":{"summary":"Filter is a raw tmux filter expression evaluated by tmux."},"source":{"file":"tmux/server_buffers.go","line":83,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ListBuffersRequest.Filter","product":"core","slug":"tmux-listbuffersrequest-filter"},{"id":"tmux.Server.SetBuffer","name":"SetBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SetBufferRequest"}],"returns":"error"}],"doc":{"summary":"SetBuffer stores or appends exact string data without refreshing models. It mutates the selected paste buffer; completed stderr is reported as a redacted command error because Data may be secret. Cancellation does not prove that tmux did not store data."},"source":{"file":"tmux/server_buffers.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SetBuffer","product":"core","slug":"tmux-server-setbuffer"},{"id":"tmux.Server.ShowBuffer","name":"ShowBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"*string"}],"returns":"(string, error)"}],"doc":{"summary":"ShowBuffer returns one buffer using Python-compatible line reconstruction. The returned string is owned by the caller; nil Name selects tmux's most recent buffer. Completed stderr is an error."},"source":{"file":"tmux/server_buffers.go","line":118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ShowBuffer","product":"core","slug":"tmux-server-showbuffer"},{"id":"tmux.Server.ShowBufferBytes","name":"ShowBufferBytes","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"*string"}],"returns":"([]byte, error)"}],"doc":{"summary":"ShowBufferBytes returns one buffer as exact caller-owned tmux stdout bytes. Unlike [Server.ShowBuffer], it preserves invalid UTF-8, delimiters, and trailing newlines. Nil Name selects tmux's most recent buffer. Completed stderr returns a redacted command error and a nil byte slice."},"source":{"file":"tmux/server_buffers.go","line":130,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ShowBufferBytes","product":"core","slug":"tmux-server-showbufferbytes"},{"id":"tmux.Server.DeleteBuffer","name":"DeleteBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"*string"}],"returns":"error"}],"doc":{"summary":"DeleteBuffer deletes a named buffer, or the most recent buffer when name is nil. Cancellation does not prove that tmux did not delete the buffer."},"source":{"file":"tmux/server_buffers.go","line":157,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.DeleteBuffer","product":"core","slug":"tmux-server-deletebuffer"},{"id":"tmux.Server.SaveBuffer","name":"SaveBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SaveBufferRequest"}],"returns":"error"}],"doc":{"summary":"SaveBuffer writes a named or most-recent buffer to a file. Path follows [Server.SourceFile]'s current-user expansion and lexical normalization. It changes that file. Exact \"-\" is rejected because it names tmux's stdout rather than a path; [Server.SaveBufferTo] streams to an [io.Writer], and this method is the one that runs over a [Connection]."},"source":{"file":"tmux/server_buffers.go","line":174,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SaveBuffer","product":"core","slug":"tmux-server-savebuffer"},{"id":"tmux.Server.LoadBuffer","name":"LoadBuffer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"LoadBufferRequest"}],"returns":"error"}],"doc":{"summary":"LoadBuffer reads a file into a named or newly allocated buffer. Path follows [Server.SourceFile]'s current-user expansion and lexical normalization. It mutates tmux's destination buffer. Exact \"-\" is rejected because it names tmux's stdin rather than a path; [Server.LoadBufferFrom] streams from an [io.Reader], and this method is the one that runs over a [Connection]."},"source":{"file":"tmux/server_buffers.go","line":199,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.LoadBuffer","product":"core","slug":"tmux-server-loadbuffer"},{"id":"tmux.Server.LoadBufferFrom","name":"LoadBufferFrom","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"source","type":"io.Reader"},{"name":"options","type":"LoadBufferFromOptions"}],"returns":"error"}],"doc":{"summary":"LoadBufferFrom streams source into a named or newly allocated tmux paste buffer, reading it to completion without holding its contents in memory. It carries any bytes, including NUL, and is bounded by neither argv nor tmux's command-message limit, which is what [Server.SetBuffer] is bounded by.","body":"A copy failure after tmux exits zero means the buffer holds only the prefix\nthat reached tmux, and cancellation does not prove tmux stored nothing. A\nsource that blocks regardless of cancellation does not hold the call, and is\nstill being read when it returns. A [Connection]-bound Server returns\n[ErrConnectionRequiresProcess]: tmux offers no stdin to a control client, so\nuse [Server.LoadBuffer] and a path over a connection."},"source":{"file":"tmux/server_buffers.go","line":227,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.LoadBufferFrom","product":"core","slug":"tmux-server-loadbufferfrom"},{"id":"tmux.Server.SaveBufferTo","name":"SaveBufferTo","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"destination","type":"io.Writer"},{"name":"options","type":"SaveBufferToOptions"}],"returns":"error"}],"doc":{"summary":"SaveBufferTo streams a named or most-recent tmux paste buffer into destination without holding its contents in memory. It writes any bytes, including NUL, and preserves them exactly where [Server.ShowBuffer] reconstructs lines.","body":"Cancellation does not prove destination received a complete buffer, and a\ncopy failure takes precedence over a completed command's exit status because\nit means destination never saw everything tmux sent. A destination that\nblocks regardless of cancellation does not hold the call. A\n[Connection]-bound Server returns [ErrConnectionRequiresProcess]: tmux\noffers no stdout to a control client, so use [Server.SaveBuffer] and a path\nover a connection."},"source":{"file":"tmux/server_buffers.go","line":259,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SaveBufferTo","product":"core","slug":"tmux-server-savebufferto"},{"id":"tmux.Server.ListBuffers","name":"ListBuffers","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ListBuffersRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ListBuffers returns an owned snapshot of live tmux buffer rows. A command or transport failure is returned rather than answered with no rows; context cancellation still returns its context error. The result is not a live collection."},"source":{"file":"tmux/server_buffers.go","line":283,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ListBuffers","product":"core","slug":"tmux-server-listbuffers"},{"id":"tmux.ServerAccessRequest","name":"ServerAccessRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerAccessRequest configures tmux server access control. Its zero value is invalid: List or exactly one nonempty Allow or Deny is required. Allow and Deny, and ReadOnly and Write, are mutually exclusive; nil pointers omit their selectors while explicit empty users are rejected. List selects the returned-list path, but compatible selector and mode flags are still sent to tmux rather than ignored."},"source":{"file":"tmux/server_clients.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerAccessRequest","product":"core","slug":"tmux-serveraccessrequest"},{"id":"tmux.ServerAccessRequest.Allow","name":"Allow","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"*string","doc":{"summary":"Allow grants the named user access."},"source":{"file":"tmux/server_clients.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerAccessRequest.Allow","product":"core","slug":"tmux-serveraccessrequest-allow"},{"id":"tmux.ServerAccessRequest.Deny","name":"Deny","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"*string","doc":{"summary":"Deny revokes the named user's access."},"source":{"file":"tmux/server_clients.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerAccessRequest.Deny","product":"core","slug":"tmux-serveraccessrequest-deny"},{"id":"tmux.ServerAccessRequest.List","name":"List","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"bool","doc":{"summary":"List returns the configured access entries instead of mutating them."},"source":{"file":"tmux/server_clients.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerAccessRequest.List","product":"core","slug":"tmux-serveraccessrequest-list"},{"id":"tmux.ServerAccessRequest.ReadOnly","name":"ReadOnly","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"bool","doc":{"summary":"ReadOnly grants read-only access to the selected user."},"source":{"file":"tmux/server_clients.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerAccessRequest.ReadOnly","product":"core","slug":"tmux-serveraccessrequest-readonly"},{"id":"tmux.ServerAccessRequest.Write","name":"Write","kind":"attribute","modifiers":[],"parent":"tmux.ServerAccessRequest","signatures":[],"type":"bool","doc":{"summary":"Write grants write access to the selected user."},"source":{"file":"tmux/server_clients.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerAccessRequest.Write","product":"core","slug":"tmux-serveraccessrequest-write"},{"id":"tmux.RefreshClientRequest","name":"RefreshClientRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RefreshClientRequest configures refreshing one tmux client. Its zero value refreshes tmux's current client; a zero TargetClient omits -t."},"source":{"file":"tmux/server_clients.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RefreshClientRequest","product":"core","slug":"tmux-refreshclientrequest"},{"id":"tmux.RefreshClientRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.RefreshClientRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects a stable client; zero selects tmux's current client."},"source":{"file":"tmux/server_clients.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RefreshClientRequest.TargetClient","product":"core","slug":"tmux-refreshclientrequest-targetclient"},{"id":"tmux.RefreshClientRequest.RequestClipboard","name":"RequestClipboard","kind":"attribute","modifiers":[],"parent":"tmux.RefreshClientRequest","signatures":[],"type":"bool","doc":{"summary":"RequestClipboard requests clipboard data and requires tmux 3.4; older tmux versions may exit when given the flag, so it follows UnsupportedPolicy."},"source":{"file":"tmux/server_clients.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RefreshClientRequest.RequestClipboard","product":"core","slug":"tmux-refreshclientrequest-requestclipboard"},{"id":"tmux.DetachClientRequest","name":"DetachClientRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DetachClientRequest configures detaching one tmux client. Its zero value detaches tmux's current client; nil fields omit their flags while an empty ShellCommand pointer is explicit."},"source":{"file":"tmux/server_clients.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachClientRequest","product":"core","slug":"tmux-detachclientrequest"},{"id":"tmux.DetachClientRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.DetachClientRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects a stable client; zero selects tmux's current client."},"source":{"file":"tmux/server_clients.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachClientRequest.TargetClient","product":"core","slug":"tmux-detachclientrequest-targetclient"},{"id":"tmux.DetachClientRequest.ShellCommand","name":"ShellCommand","kind":"attribute","modifiers":[],"parent":"tmux.DetachClientRequest","signatures":[],"type":"*string","doc":{"summary":"ShellCommand is run after detaching when nonnil."},"source":{"file":"tmux/server_clients.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachClientRequest.ShellCommand","product":"core","slug":"tmux-detachclientrequest-shellcommand"},{"id":"tmux.DetachAllClientsRequest","name":"DetachAllClientsRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DetachAllClientsRequest configures detaching every client except one. Its zero value keeps tmux's current client; nil fields omit their flags."},"source":{"file":"tmux/server_clients.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachAllClientsRequest","product":"core","slug":"tmux-detachallclientsrequest"},{"id":"tmux.DetachAllClientsRequest.KeepClient","name":"KeepClient","kind":"attribute","modifiers":[],"parent":"tmux.DetachAllClientsRequest","signatures":[],"type":"ClientName","doc":{"summary":"KeepClient selects the stable client to retain; zero keeps tmux's current client."},"source":{"file":"tmux/server_clients.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachAllClientsRequest.KeepClient","product":"core","slug":"tmux-detachallclientsrequest-keepclient"},{"id":"tmux.DetachAllClientsRequest.ShellCommand","name":"ShellCommand","kind":"attribute","modifiers":[],"parent":"tmux.DetachAllClientsRequest","signatures":[],"type":"*string","doc":{"summary":"ShellCommand is run after detaching when nonnil."},"source":{"file":"tmux/server_clients.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DetachAllClientsRequest.ShellCommand","product":"core","slug":"tmux-detachallclientsrequest-shellcommand"},{"id":"tmux.Server.ServerAccess","name":"ServerAccess","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ServerAccessRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ServerAccess changes or lists the server access-control entries. It requires tmux 3.3 and returns [VersionTooLowError] below that floor. List returns an owned snapshot, and reports a completed or transport failure rather than answering with no entries; mutation completed stderr is an error."},"source":{"file":"tmux/server_clients.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ServerAccess","product":"core","slug":"tmux-server-serveraccess"},{"id":"tmux.Server.LockServer","name":"LockServer","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"LockServer locks every attached client on the tmux server. Cancellation does not prove the server did not lock a client."},"source":{"file":"tmux/server_clients.go","line":151,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.LockServer","product":"core","slug":"tmux-server-lockserver"},{"id":"tmux.Server.RefreshClient","name":"RefreshClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RefreshClientRequest"}],"returns":"error"}],"doc":{"summary":"RefreshClient redraws a client, or tmux's current client when no target is set. RequestClipboard requires tmux 3.4 and follows [UnsupportedPolicy]."},"source":{"file":"tmux/server_clients.go","line":157,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.RefreshClient","product":"core","slug":"tmux-server-refreshclient"},{"id":"tmux.Server.LockClient","name":"LockClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"targetClient","type":"*ClientName"}],"returns":"error"}],"doc":{"summary":"LockClient locks a client, or tmux's current client when targetClient is nil. Cancellation does not prove the target client was not locked."},"source":{"file":"tmux/server_clients.go","line":191,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.LockClient","product":"core","slug":"tmux-server-lockclient"},{"id":"tmux.Server.SuspendClient","name":"SuspendClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"targetClient","type":"*ClientName"}],"returns":"error"}],"doc":{"summary":"SuspendClient suspends a client, or tmux's current client when targetClient is nil. Cancellation does not prove suspension did not occur."},"source":{"file":"tmux/server_clients.go","line":205,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SuspendClient","product":"core","slug":"tmux-server-suspendclient"},{"id":"tmux.Server.DetachClient","name":"DetachClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DetachClientRequest"}],"returns":"error"}],"doc":{"summary":"DetachClient detaches one client, or tmux's current client when no target is set. A completed stderr result is an error; cancellation does not prove delivery or detachment did not occur."},"source":{"file":"tmux/server_clients.go","line":220,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.DetachClient","product":"core","slug":"tmux-server-detachclient"},{"id":"tmux.Server.DetachAllClients","name":"DetachAllClients","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DetachAllClientsRequest"}],"returns":"error"}],"doc":{"summary":"DetachAllClients detaches every client except KeepClient or tmux's current client. Cancellation does not prove every client was detached."},"source":{"file":"tmux/server_clients.go","line":245,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.DetachAllClients","product":"core","slug":"tmux-server-detachallclients"},{"id":"tmux.Server.SwitchClient","name":"SwitchClient","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"targetSession","type":"string"}],"returns":"error"}],"doc":{"summary":"SwitchClient switches tmux's current client to targetSession. TargetSession is a validated session name rather than a stable identity; cancellation does not prove the switch did not occur.","body":"The target is sent anchored with tmux's \"=\" exact-match prefix: an\nunanchored \"-t name\" resolves by prefix, so a name that matches no session\nexactly but starts a different one's name would otherwise switch there\nsilently instead of failing. The anchor is safe here because\nvalidateLifecycleSessionName has already refused the period or colon that\nwould make \"=name\" misread the target itself."},"source":{"file":"tmux/server_clients.go","line":281,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SwitchClient","product":"core","slug":"tmux-server-switchclient"},{"id":"tmux.Session.Lock","name":"Lock","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Lock locks every client attached to the session identified by this handle's stable ID. Cancellation does not prove that tmux did not lock a client."},"source":{"file":"tmux/server_clients.go","line":295,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Lock","product":"core","slug":"tmux-session-lock"},{"id":"tmux.Session.DetachClients","name":"DetachClients","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"shellCommand","type":"*string"}],"returns":"error"}],"doc":{"summary":"DetachClients detaches every client attached to the session identified by this handle's stable ID. A nonnil ShellCommand is run after detaching."},"source":{"file":"tmux/server_clients.go","line":316,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.DetachClients","product":"core","slug":"tmux-session-detachclients"},{"id":"tmux.Session.SwitchClient","name":"SwitchClient","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"SwitchClient switches tmux's current client to the session identified by this handle's stable ID."},"source":{"file":"tmux/server_clients.go","line":345,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SwitchClient","product":"core","slug":"tmux-session-switchclient"},{"id":"tmux.ErrInvalidServerCommandRequest","name":"ErrInvalidServerCommandRequest","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidServerCommandRequest identifies a server command request that cannot be represented safely as tmux arguments."},"source":{"file":"tmux/server_exec.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidServerCommandRequest","product":"core","slug":"tmux-errinvalidservercommandrequest"},{"id":"tmux.ServerCommandRequestError","name":"ServerCommandRequestError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerCommandRequestError reports a locally rejected server command request field. Callers can use [errors.Is] with [ErrInvalidServerCommandRequest] or [errors.As] to inspect it. Value is redacted only when that field's validator requests redaction."},"source":{"file":"tmux/server_exec.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerCommandRequestError","product":"core","slug":"tmux-servercommandrequesterror"},{"id":"tmux.ServerCommandRequestError.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[],"type":"string","doc":{"summary":"Subcommand is the tmux command whose request was rejected."},"source":{"file":"tmux/server_exec.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerCommandRequestError.Subcommand","product":"core","slug":"tmux-servercommandrequesterror-subcommand"},{"id":"tmux.ServerCommandRequestError.Field","name":"Field","kind":"attribute","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[],"type":"string","doc":{"summary":"Field is the request field that was rejected."},"source":{"file":"tmux/server_exec.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerCommandRequestError.Field","product":"core","slug":"tmux-servercommandrequesterror-field"},{"id":"tmux.ServerCommandRequestError.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[],"type":"string","doc":{"summary":"Value is the rejected value, or \"[redacted]\" for a secret-sensitive field."},"source":{"file":"tmux/server_exec.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerCommandRequestError.Value","product":"core","slug":"tmux-servercommandrequesterror-value"},{"id":"tmux.ServerCommandRequestError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[],"type":"string","doc":{"summary":"Reason describes the validation failure without changing the sentinel error."},"source":{"file":"tmux/server_exec.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerCommandRequestError.Reason","product":"core","slug":"tmux-servercommandrequesterror-reason"},{"id":"tmux.ServerCommandRequestError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/server_exec.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerCommandRequestError.Error","product":"core","slug":"tmux-servercommandrequesterror-error"},{"id":"tmux.ServerCommandRequestError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.ServerCommandRequestError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes ServerCommandRequestError compatible with ErrInvalidServerCommandRequest."},"source":{"file":"tmux/server_exec.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerCommandRequestError.Unwrap","product":"core","slug":"tmux-servercommandrequesterror-unwrap"},{"id":"tmux.RunShellRequest","name":"RunShellRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RunShellRequest configures a command executed by tmux's run-shell command. Its zero value is invalid because Command is required. Pointer fields distinguish omitted flags from explicit empty arguments; RunShell copies Delay, StartDirectory, and Args before invoking tmux."},"source":{"file":"tmux/server_exec.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest","product":"core","slug":"tmux-runshellrequest"},{"id":"tmux.RunShellRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"string","doc":{"summary":"Command is the required shell or tmux command to run."},"source":{"file":"tmux/server_exec.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest.Command","product":"core","slug":"tmux-runshellrequest-command"},{"id":"tmux.RunShellRequest.Background","name":"Background","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"bool","doc":{"summary":"Background returns after tmux accepts the job instead of waiting for stdout."},"source":{"file":"tmux/server_exec.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest.Background","product":"core","slug":"tmux-runshellrequest-background"},{"id":"tmux.RunShellRequest.Delay","name":"Delay","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"*string","doc":{"summary":"Delay supplies run-shell's optional delay; nil omits it and an empty value is explicit."},"source":{"file":"tmux/server_exec.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest.Delay","product":"core","slug":"tmux-runshellrequest-delay"},{"id":"tmux.RunShellRequest.AsTmuxCommand","name":"AsTmuxCommand","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"bool","doc":{"summary":"AsTmuxCommand asks tmux to interpret Command as tmux command syntax."},"source":{"file":"tmux/server_exec.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest.AsTmuxCommand","product":"core","slug":"tmux-runshellrequest-astmuxcommand"},{"id":"tmux.RunShellRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"PaneID","doc":{"summary":"TargetPane selects a stable pane target; its zero value leaves target selection to tmux."},"source":{"file":"tmux/server_exec.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest.TargetPane","product":"core","slug":"tmux-runshellrequest-targetpane"},{"id":"tmux.RunShellRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"*string","doc":{"summary":"StartDirectory selects the job directory; nil omits it. It requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_exec.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest.StartDirectory","product":"core","slug":"tmux-runshellrequest-startdirectory"},{"id":"tmux.RunShellRequest.ShowStderr","name":"ShowStderr","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"bool","doc":{"summary":"ShowStderr requests job stderr and requires tmux 3.6; see UnsupportedPolicy."},"source":{"file":"tmux/server_exec.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest.ShowStderr","product":"core","slug":"tmux-runshellrequest-showstderr"},{"id":"tmux.RunShellRequest.Args","name":"Args","kind":"attribute","modifiers":[],"parent":"tmux.RunShellRequest","signatures":[],"type":"[]string","doc":{"summary":"Args are extra job arguments copied before tmux runs. They require tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/server_exec.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunShellRequest.Args","product":"core","slug":"tmux-runshellrequest-args"},{"id":"tmux.WaitForMode","name":"WaitForMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WaitForMode selects one wait-for operation. The zero value waits until the channel is signaled."},"source":{"file":"tmux/server_exec.go","line":85,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WaitForMode","product":"core","slug":"tmux-waitformode"},{"id":"tmux.WaitForModeWait","name":"WaitForModeWait","kind":"constant","modifiers":[],"signatures":[],"type":"WaitForMode","doc":{"summary":"WaitForModeWait waits until another client signals Channel."},"source":{"file":"tmux/server_exec.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WaitForModeWait","product":"core","slug":"tmux-waitformodewait"},{"id":"tmux.WaitForModeSignal","name":"WaitForModeSignal","kind":"constant","modifiers":[],"signatures":[],"type":"WaitForMode","doc":{"summary":"WaitForModeSignal signals Channel and wakes waiters."},"source":{"file":"tmux/server_exec.go","line":92,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WaitForModeSignal","product":"core","slug":"tmux-waitformodesignal"},{"id":"tmux.WaitForModeLock","name":"WaitForModeLock","kind":"constant","modifiers":[],"signatures":[],"type":"WaitForMode","doc":{"summary":"WaitForModeLock acquires Channel's tmux mutex, queuing behind another locker if it is already held.","body":"Before tmux 3.8, a cancelled or timed-out ctx while queued costs Channel\none unlock: tmux hands the mutex to the next queued client whether or\nnot it is still there, and the one that has gone cannot pass it on\n(cmd-wait-for.c cmd_wait_for_unlock). Unlocking again hands it to the\nnext real locker, so a channel is not lost, but a program that abandons\nlock waits and counts its unlocks will deadlock on its own arithmetic.\ntmux 3.8 drops the wait of a client that has gone (tmux issue 5614), so\nthere an abandoned wait costs nothing and an extra unlock fails."},"source":{"file":"tmux/server_exec.go","line":104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WaitForModeLock","product":"core","slug":"tmux-waitformodelock"},{"id":"tmux.WaitForModeUnlock","name":"WaitForModeUnlock","kind":"constant","modifiers":[],"signatures":[],"type":"WaitForMode","doc":{"summary":"WaitForModeUnlock releases Channel's tmux mutex."},"source":{"file":"tmux/server_exec.go","line":106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WaitForModeUnlock","product":"core","slug":"tmux-waitformodeunlock"},{"id":"tmux.WaitForRequest","name":"WaitForRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WaitForRequest configures a wait, signal, lock, or unlock operation. Its zero value waits on the required nonempty Channel."},"source":{"file":"tmux/server_exec.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WaitForRequest","product":"core","slug":"tmux-waitforrequest"},{"id":"tmux.WaitForRequest.Channel","name":"Channel","kind":"attribute","modifiers":[],"parent":"tmux.WaitForRequest","signatures":[],"type":"string","doc":{"summary":"Channel names the tmux wait-for channel or mutex."},"source":{"file":"tmux/server_exec.go","line":113,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WaitForRequest.Channel","product":"core","slug":"tmux-waitforrequest-channel"},{"id":"tmux.WaitForRequest.Mode","name":"Mode","kind":"attribute","modifiers":[],"parent":"tmux.WaitForRequest","signatures":[],"type":"WaitForMode","doc":{"summary":"Mode selects the channel action; zero waits."},"source":{"file":"tmux/server_exec.go","line":115,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WaitForRequest.Mode","product":"core","slug":"tmux-waitforrequest-mode"},{"id":"tmux.IfShellRequest","name":"IfShellRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"IfShellRequest configures conditional execution of a tmux command. Its zero value is invalid because ShellCommand and ThenCommand are required; nil ElseCommand omits the failure branch while a pointer to an empty string is explicit."},"source":{"file":"tmux/server_exec.go","line":122,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.IfShellRequest","product":"core","slug":"tmux-ifshellrequest"},{"id":"tmux.IfShellRequest.ShellCommand","name":"ShellCommand","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"string","doc":{"summary":"ShellCommand is the required shell condition executed by tmux."},"source":{"file":"tmux/server_exec.go","line":124,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.IfShellRequest.ShellCommand","product":"core","slug":"tmux-ifshellrequest-shellcommand"},{"id":"tmux.IfShellRequest.ThenCommand","name":"ThenCommand","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"string","doc":{"summary":"ThenCommand is the required tmux command executed when ShellCommand succeeds."},"source":{"file":"tmux/server_exec.go","line":126,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.IfShellRequest.ThenCommand","product":"core","slug":"tmux-ifshellrequest-thencommand"},{"id":"tmux.IfShellRequest.ElseCommand","name":"ElseCommand","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"*string","doc":{"summary":"ElseCommand is the optional tmux command executed when ShellCommand fails."},"source":{"file":"tmux/server_exec.go","line":128,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.IfShellRequest.ElseCommand","product":"core","slug":"tmux-ifshellrequest-elsecommand"},{"id":"tmux.IfShellRequest.Background","name":"Background","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"bool","doc":{"summary":"Background makes tmux schedule the conditional command without waiting."},"source":{"file":"tmux/server_exec.go","line":130,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.IfShellRequest.Background","product":"core","slug":"tmux-ifshellrequest-background"},{"id":"tmux.IfShellRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.IfShellRequest","signatures":[],"type":"PaneID","doc":{"summary":"TargetPane selects a stable pane target; its zero value omits -t."},"source":{"file":"tmux/server_exec.go","line":132,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.IfShellRequest.TargetPane","product":"core","slug":"tmux-ifshellrequest-targetpane"},{"id":"tmux.SourceFileRequest","name":"SourceFileRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SourceFileRequest configures loading or parsing a tmux configuration file. Its zero value is invalid because Path is required; SourceFile expands only the current user's ~ forms and copies no caller-owned mutable input."},"source":{"file":"tmux/server_exec.go","line":138,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SourceFileRequest","product":"core","slug":"tmux-sourcefilerequest"},{"id":"tmux.SourceFileRequest.Path","name":"Path","kind":"attribute","modifiers":[],"parent":"tmux.SourceFileRequest","signatures":[],"type":"string","doc":{"summary":"Path is the required configuration path; exact \"-\" is rejected because no stdin is provided."},"source":{"file":"tmux/server_exec.go","line":140,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SourceFileRequest.Path","product":"core","slug":"tmux-sourcefilerequest-path"},{"id":"tmux.SourceFileRequest.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.SourceFileRequest","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux diagnostics for missing source files."},"source":{"file":"tmux/server_exec.go","line":142,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SourceFileRequest.Quiet","product":"core","slug":"tmux-sourcefilerequest-quiet"},{"id":"tmux.SourceFileRequest.ParseOnly","name":"ParseOnly","kind":"attribute","modifiers":[],"parent":"tmux.SourceFileRequest","signatures":[],"type":"bool","doc":{"summary":"ParseOnly validates the file without applying its commands."},"source":{"file":"tmux/server_exec.go","line":144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SourceFileRequest.ParseOnly","product":"core","slug":"tmux-sourcefilerequest-parseonly"},{"id":"tmux.SourceFileRequest.Verbose","name":"Verbose","kind":"attribute","modifiers":[],"parent":"tmux.SourceFileRequest","signatures":[],"type":"bool","doc":{"summary":"Verbose requests tmux parsing diagnostics."},"source":{"file":"tmux/server_exec.go","line":146,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SourceFileRequest.Verbose","product":"core","slug":"tmux-sourcefilerequest-verbose"},{"id":"tmux.Server.RunShell","name":"RunShell","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RunShellRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"RunShell executes a shell command through tmux and returns an owned stdout slice. A background request returns nil after tmux accepts the job. Unsupported optional flags follow [UnsupportedPolicy]. A completed stderr result is an error; context cancellation can be observed with [errors.Is] but does not establish that tmux did not start the job."},"source":{"file":"tmux/server_exec.go","line":154,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.RunShell","product":"core","slug":"tmux-server-runshell"},{"id":"tmux.Server.WaitFor","name":"WaitFor","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"WaitForRequest"}],"returns":"error"}],"doc":{"summary":"WaitFor waits for, signals, locks, or unlocks a named tmux channel. It changes only that server-side channel state; cancellation can interrupt the client wait but cannot prove a preceding signal or lock did not take effect. See [WaitForModeLock]: before tmux 3.8, abandoning a lock wait costs that channel one unlock."},"source":{"file":"tmux/server_exec.go","line":250,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.WaitFor","product":"core","slug":"tmux-server-waitfor"},{"id":"tmux.Server.IfShell","name":"IfShell","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"IfShellRequest"}],"returns":"error"}],"doc":{"summary":"IfShell executes ThenCommand when ShellCommand succeeds and ElseCommand, if present, when it fails. A completed stderr result is an error; cancellation can interrupt delivery without proving that tmux did not execute a branch."},"source":{"file":"tmux/server_exec.go","line":284,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.IfShell","product":"core","slug":"tmux-server-ifshell"},{"id":"tmux.Server.SourceFile","name":"SourceFile","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SourceFileRequest"}],"returns":"error"}],"doc":{"summary":"SourceFile loads or parses one tmux configuration file. The path expands ~ and ~/... for the current user and normalizes redundant separators and dot components without collapsing parent components. Named-user forms are rejected. Exact \"-\" is rejected because it requires process stdin; a relative path naming a file called \"-\" remains file data. It can mutate tmux configuration; completed stderr is an error, and cancellation does not prove that parsing or sourcing did not occur."},"source":{"file":"tmux/server_exec.go","line":324,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SourceFile","product":"core","slug":"tmux-server-sourcefile"},{"id":"tmux.ConfirmBeforeRequest","name":"ConfirmBeforeRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ConfirmBeforeRequest configures a background tmux confirmation prompt. Its zero value is invalid because Command is required. Nil pointer fields omit their flags while explicit empty strings are passed to tmux; ConfirmKey must be one printable ASCII character."},"source":{"file":"tmux/server_interactive.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ConfirmBeforeRequest","product":"core","slug":"tmux-confirmbeforerequest"},{"id":"tmux.ConfirmBeforeRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"string","doc":{"summary":"Command is the required tmux command shown for confirmation."},"source":{"file":"tmux/server_interactive.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ConfirmBeforeRequest.Command","product":"core","slug":"tmux-confirmbeforerequest-command"},{"id":"tmux.ConfirmBeforeRequest.Prompt","name":"Prompt","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"*string","doc":{"summary":"Prompt replaces tmux's prompt when nonnil."},"source":{"file":"tmux/server_interactive.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ConfirmBeforeRequest.Prompt","product":"core","slug":"tmux-confirmbeforerequest-prompt"},{"id":"tmux.ConfirmBeforeRequest.ConfirmKey","name":"ConfirmKey","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"*string","doc":{"summary":"ConfirmKey selects the affirmative key and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ConfirmBeforeRequest.ConfirmKey","product":"core","slug":"tmux-confirmbeforerequest-confirmkey"},{"id":"tmux.ConfirmBeforeRequest.DefaultYes","name":"DefaultYes","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"bool","doc":{"summary":"DefaultYes selects yes by default and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ConfirmBeforeRequest.DefaultYes","product":"core","slug":"tmux-confirmbeforerequest-defaultyes"},{"id":"tmux.ConfirmBeforeRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.ConfirmBeforeRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the stable client that displays the prompt."},"source":{"file":"tmux/server_interactive.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ConfirmBeforeRequest.TargetClient","product":"core","slug":"tmux-confirmbeforerequest-targetclient"},{"id":"tmux.CommandPromptRequest","name":"CommandPromptRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"CommandPromptRequest configures a background tmux command prompt. Its zero value is invalid because Template is required; nil pointer fields omit flags while explicit empty values are passed to tmux."},"source":{"file":"tmux/server_interactive.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest","product":"core","slug":"tmux-commandpromptrequest"},{"id":"tmux.CommandPromptRequest.Template","name":"Template","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"string","doc":{"summary":"Template is the required tmux command template submitted by the prompt."},"source":{"file":"tmux/server_interactive.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.Template","product":"core","slug":"tmux-commandpromptrequest-template"},{"id":"tmux.CommandPromptRequest.Prompt","name":"Prompt","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"*string","doc":{"summary":"Prompt replaces tmux's prompt text when nonnil."},"source":{"file":"tmux/server_interactive.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.Prompt","product":"core","slug":"tmux-commandpromptrequest-prompt"},{"id":"tmux.CommandPromptRequest.Inputs","name":"Inputs","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"*string","doc":{"summary":"Inputs supplies initial prompt inputs when nonnil."},"source":{"file":"tmux/server_interactive.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.Inputs","product":"core","slug":"tmux-commandpromptrequest-inputs"},{"id":"tmux.CommandPromptRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the stable client that displays the prompt."},"source":{"file":"tmux/server_interactive.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.TargetClient","product":"core","slug":"tmux-commandpromptrequest-targetclient"},{"id":"tmux.CommandPromptRequest.OneKey","name":"OneKey","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"OneKey accepts one key rather than a line."},"source":{"file":"tmux/server_interactive.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.OneKey","product":"core","slug":"tmux-commandpromptrequest-onekey"},{"id":"tmux.CommandPromptRequest.KeyOnly","name":"KeyOnly","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"KeyOnly limits accepted input to keys."},"source":{"file":"tmux/server_interactive.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.KeyOnly","product":"core","slug":"tmux-commandpromptrequest-keyonly"},{"id":"tmux.CommandPromptRequest.OnInputChange","name":"OnInputChange","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"OnInputChange runs Template after each input change."},"source":{"file":"tmux/server_interactive.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.OnInputChange","product":"core","slug":"tmux-commandpromptrequest-oninputchange"},{"id":"tmux.CommandPromptRequest.Numeric","name":"Numeric","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"Numeric restricts accepted input to a number."},"source":{"file":"tmux/server_interactive.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.Numeric","product":"core","slug":"tmux-commandpromptrequest-numeric"},{"id":"tmux.CommandPromptRequest.Type","name":"Type","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"PromptType","doc":{"summary":"Type selects the associated prompt-history class; zero omits -T."},"source":{"file":"tmux/server_interactive.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.Type","product":"core","slug":"tmux-commandpromptrequest-type"},{"id":"tmux.CommandPromptRequest.ExpandFormat","name":"ExpandFormat","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"ExpandFormat expands formats in the prompt result."},"source":{"file":"tmux/server_interactive.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.ExpandFormat","product":"core","slug":"tmux-commandpromptrequest-expandformat"},{"id":"tmux.CommandPromptRequest.Literal","name":"Literal","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"Literal disables key-name parsing and requires tmux 3.6; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.Literal","product":"core","slug":"tmux-commandpromptrequest-literal"},{"id":"tmux.CommandPromptRequest.BackspaceExit","name":"BackspaceExit","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"BackspaceExit exits on backspace and requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":64,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.BackspaceExit","product":"core","slug":"tmux-commandpromptrequest-backspaceexit"},{"id":"tmux.CommandPromptRequest.NoFreeze","name":"NoFreeze","kind":"attribute","modifiers":[],"parent":"tmux.CommandPromptRequest","signatures":[],"type":"bool","doc":{"summary":"NoFreeze leaves the pane unfrozen and requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.CommandPromptRequest.NoFreeze","product":"core","slug":"tmux-commandpromptrequest-nofreeze"},{"id":"tmux.MenuItem","name":"MenuItem","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MenuItem is one display-menu entry. Its zero value is a separator. A named item always contributes its name, key, and command to tmux, including empty key or command strings."},"source":{"file":"tmux/server_interactive.go","line":73,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuItem","product":"core","slug":"tmux-menuitem"},{"id":"tmux.MenuItem.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.MenuItem","signatures":[],"type":"string","doc":{"summary":"Name is the visible item name; an empty name makes this item a separator."},"source":{"file":"tmux/server_interactive.go","line":75,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuItem.Name","product":"core","slug":"tmux-menuitem-name"},{"id":"tmux.MenuItem.Key","name":"Key","kind":"attribute","modifiers":[],"parent":"tmux.MenuItem","signatures":[],"type":"string","doc":{"summary":"Key is the optional shortcut for a named item."},"source":{"file":"tmux/server_interactive.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuItem.Key","product":"core","slug":"tmux-menuitem-key"},{"id":"tmux.MenuItem.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.MenuItem","signatures":[],"type":"string","doc":{"summary":"Command is the tmux command for a named item."},"source":{"file":"tmux/server_interactive.go","line":79,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MenuItem.Command","product":"core","slug":"tmux-menuitem-command"},{"id":"tmux.DisplayMenuRequest","name":"DisplayMenuRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"DisplayMenuRequest configures one tmux popup menu. Position and style strings retain tmux's format and symbolic-position languages verbatim. Its zero value is invalid because Items is required. All pointer fields omit their flags when nil and retain explicit empty strings; DisplayMenu copies Items before calling tmux. TargetPane and TargetClient are independent but must be stable identities when present."},"source":{"file":"tmux/server_interactive.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest","product":"core","slug":"tmux-displaymenurequest"},{"id":"tmux.DisplayMenuRequest.Items","name":"Items","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"[]MenuItem","doc":{"summary":"Items are menu rows; a zero MenuItem is a separator."},"source":{"file":"tmux/server_interactive.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.Items","product":"core","slug":"tmux-displaymenurequest-items"},{"id":"tmux.DisplayMenuRequest.Title","name":"Title","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"Title is the optional menu title."},"source":{"file":"tmux/server_interactive.go","line":92,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.Title","product":"core","slug":"tmux-displaymenurequest-title"},{"id":"tmux.DisplayMenuRequest.TargetPane","name":"TargetPane","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"PaneID","doc":{"summary":"TargetPane supplies pane context for format expansion."},"source":{"file":"tmux/server_interactive.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.TargetPane","product":"core","slug":"tmux-displaymenurequest-targetpane"},{"id":"tmux.DisplayMenuRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects the client that renders the menu."},"source":{"file":"tmux/server_interactive.go","line":96,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.TargetClient","product":"core","slug":"tmux-displaymenurequest-targetclient"},{"id":"tmux.DisplayMenuRequest.X","name":"X","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"X is tmux's horizontal position expression."},"source":{"file":"tmux/server_interactive.go","line":98,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.X","product":"core","slug":"tmux-displaymenurequest-x"},{"id":"tmux.DisplayMenuRequest.Y","name":"Y","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"Y is tmux's vertical position expression."},"source":{"file":"tmux/server_interactive.go","line":100,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.Y","product":"core","slug":"tmux-displaymenurequest-y"},{"id":"tmux.DisplayMenuRequest.StartingChoice","name":"StartingChoice","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"StartingChoice selects the initial item and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":103,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.StartingChoice","product":"core","slug":"tmux-displaymenurequest-startingchoice"},{"id":"tmux.DisplayMenuRequest.BorderLines","name":"BorderLines","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"BorderLines selects border glyphs and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.BorderLines","product":"core","slug":"tmux-displaymenurequest-borderlines"},{"id":"tmux.DisplayMenuRequest.Style","name":"Style","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"Style selects menu style and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.Style","product":"core","slug":"tmux-displaymenurequest-style"},{"id":"tmux.DisplayMenuRequest.BorderStyle","name":"BorderStyle","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"BorderStyle selects border style and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.BorderStyle","product":"core","slug":"tmux-displaymenurequest-borderstyle"},{"id":"tmux.DisplayMenuRequest.SelectedStyle","name":"SelectedStyle","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"*string","doc":{"summary":"SelectedStyle selects highlighted-item style and requires tmux 3.4; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":114,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.SelectedStyle","product":"core","slug":"tmux-displaymenurequest-selectedstyle"},{"id":"tmux.DisplayMenuRequest.Mouse","name":"Mouse","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"bool","doc":{"summary":"Mouse enables mouse selection and requires tmux 3.5; see UnsupportedPolicy."},"source":{"file":"tmux/server_interactive.go","line":116,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.Mouse","product":"core","slug":"tmux-displaymenurequest-mouse"},{"id":"tmux.DisplayMenuRequest.StayOpen","name":"StayOpen","kind":"attribute","modifiers":[],"parent":"tmux.DisplayMenuRequest","signatures":[],"type":"bool","doc":{"summary":"StayOpen keeps the menu visible after selecting an item."},"source":{"file":"tmux/server_interactive.go","line":118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DisplayMenuRequest.StayOpen","product":"core","slug":"tmux-displaymenurequest-stayopen"},{"id":"tmux.Server.ConfirmBefore","name":"ConfirmBefore","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ConfirmBeforeRequest"}],"returns":"error"}],"doc":{"summary":"ConfirmBefore asks tmux to display a background confirmation prompt and returns after tmux accepts it, not after the user answers or Command runs. It requires tmux 3.3. ConfirmKey and DefaultYes require tmux 3.4 and follow [UnsupportedPolicy]. Completed stderr is an error; cancellation does not prove prompt delivery or later command execution did not occur."},"source":{"file":"tmux/server_interactive.go","line":183,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ConfirmBefore","product":"core","slug":"tmux-server-confirmbefore"},{"id":"tmux.Server.CommandPrompt","name":"CommandPrompt","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"CommandPromptRequest"}],"returns":"error"}],"doc":{"summary":"CommandPrompt asks tmux to display a background command prompt and returns after tmux accepts it, not after input is submitted or Template runs. It requires tmux 3.3. Later flags follow [UnsupportedPolicy]. Completed stderr is an error; cancellation does not prove prompt delivery or later execution."},"source":{"file":"tmux/server_interactive.go","line":231,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.CommandPrompt","product":"core","slug":"tmux-server-commandprompt"},{"id":"tmux.Server.DisplayMenu","name":"DisplayMenu","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"DisplayMenuRequest"}],"returns":"error"}],"doc":{"summary":"DisplayMenu displays a menu and waits until tmux closes it. The target client must own a TTY; control-mode clients cannot render menu overlays. It returns no selected value and does not establish whether an item command ran. Unsupported optional flags follow [UnsupportedPolicy]. Completed stderr is an error, and cancellation does not prove menu delivery or a selected command's effect."},"source":{"file":"tmux/server_interactive.go","line":311,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.DisplayMenu","product":"core","slug":"tmux-server-displaymenu"},{"id":"tmux.BindKeyRequest","name":"BindKeyRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"BindKeyRequest configures one tmux key binding. Its zero value is invalid because Key is required; nil KeyTable and Note omit their flags while pointers to empty strings are explicit."},"source":{"file":"tmux/server_keys.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BindKeyRequest","product":"core","slug":"tmux-bindkeyrequest"},{"id":"tmux.BindKeyRequest.Key","name":"Key","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"string","doc":{"summary":"Key is the required tmux key notation to bind."},"source":{"file":"tmux/server_keys.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BindKeyRequest.Key","product":"core","slug":"tmux-bindkeyrequest-key"},{"id":"tmux.BindKeyRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"string","doc":{"summary":"Command is the tmux command; an empty command is a no-op binding on tmux 3.3+."},"source":{"file":"tmux/server_keys.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BindKeyRequest.Command","product":"core","slug":"tmux-bindkeyrequest-command"},{"id":"tmux.BindKeyRequest.KeyTable","name":"KeyTable","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"*string","doc":{"summary":"KeyTable selects a table, or nil for tmux's default table."},"source":{"file":"tmux/server_keys.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BindKeyRequest.KeyTable","product":"core","slug":"tmux-bindkeyrequest-keytable"},{"id":"tmux.BindKeyRequest.Note","name":"Note","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"*string","doc":{"summary":"Note supplies tmux's optional binding note."},"source":{"file":"tmux/server_keys.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BindKeyRequest.Note","product":"core","slug":"tmux-bindkeyrequest-note"},{"id":"tmux.BindKeyRequest.Repeat","name":"Repeat","kind":"attribute","modifiers":[],"parent":"tmux.BindKeyRequest","signatures":[],"type":"bool","doc":{"summary":"Repeat makes the binding repeatable."},"source":{"file":"tmux/server_keys.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.BindKeyRequest.Repeat","product":"core","slug":"tmux-bindkeyrequest-repeat"},{"id":"tmux.UnbindKeyRequest","name":"UnbindKeyRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"UnbindKeyRequest selects one key or an entire key table to unbind. Exactly one of Key and AllKeys must be set."},"source":{"file":"tmux/server_keys.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnbindKeyRequest","product":"core","slug":"tmux-unbindkeyrequest"},{"id":"tmux.UnbindKeyRequest.Key","name":"Key","kind":"attribute","modifiers":[],"parent":"tmux.UnbindKeyRequest","signatures":[],"type":"*string","doc":{"summary":"Key selects one binding; it is mutually exclusive with AllKeys."},"source":{"file":"tmux/server_keys.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnbindKeyRequest.Key","product":"core","slug":"tmux-unbindkeyrequest-key"},{"id":"tmux.UnbindKeyRequest.KeyTable","name":"KeyTable","kind":"attribute","modifiers":[],"parent":"tmux.UnbindKeyRequest","signatures":[],"type":"*string","doc":{"summary":"KeyTable limits removal to one table; nil selects tmux's default table."},"source":{"file":"tmux/server_keys.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnbindKeyRequest.KeyTable","product":"core","slug":"tmux-unbindkeyrequest-keytable"},{"id":"tmux.UnbindKeyRequest.AllKeys","name":"AllKeys","kind":"attribute","modifiers":[],"parent":"tmux.UnbindKeyRequest","signatures":[],"type":"bool","doc":{"summary":"AllKeys removes every binding in KeyTable and is mutually exclusive with Key."},"source":{"file":"tmux/server_keys.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnbindKeyRequest.AllKeys","product":"core","slug":"tmux-unbindkeyrequest-allkeys"},{"id":"tmux.UnbindKeyRequest.Quiet","name":"Quiet","kind":"attribute","modifiers":[],"parent":"tmux.UnbindKeyRequest","signatures":[],"type":"bool","doc":{"summary":"Quiet suppresses tmux's missing-binding diagnostic."},"source":{"file":"tmux/server_keys.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnbindKeyRequest.Quiet","product":"core","slug":"tmux-unbindkeyrequest-quiet"},{"id":"tmux.ListKeysRequest","name":"ListKeysRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ListKeysRequest configures raw key-binding output. Its zero value selects tmux's default table and format; nil fields omit flags while explicit empty pointers are passed to tmux."},"source":{"file":"tmux/server_keys.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ListKeysRequest","product":"core","slug":"tmux-listkeysrequest"},{"id":"tmux.ListKeysRequest.KeyTable","name":"KeyTable","kind":"attribute","modifiers":[],"parent":"tmux.ListKeysRequest","signatures":[],"type":"*string","doc":{"summary":"KeyTable limits output to one key table."},"source":{"file":"tmux/server_keys.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ListKeysRequest.KeyTable","product":"core","slug":"tmux-listkeysrequest-keytable"},{"id":"tmux.ListKeysRequest.Format","name":"Format","kind":"attribute","modifiers":[],"parent":"tmux.ListKeysRequest","signatures":[],"type":"*string","doc":{"summary":"Format selects output format and requires tmux 3.7; see UnsupportedPolicy."},"source":{"file":"tmux/server_keys.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ListKeysRequest.Format","product":"core","slug":"tmux-listkeysrequest-format"},{"id":"tmux.ListCommandsRequest","name":"ListCommandsRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ListCommandsRequest optionally limits output to one tmux command or alias. Nil CommandName lists all commands; a pointer to an empty name is explicit."},"source":{"file":"tmux/server_keys.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ListCommandsRequest","product":"core","slug":"tmux-listcommandsrequest"},{"id":"tmux.ListCommandsRequest.CommandName","name":"CommandName","kind":"attribute","modifiers":[],"parent":"tmux.ListCommandsRequest","signatures":[],"type":"*string","doc":{"summary":"CommandName optionally selects one command or alias."},"source":{"file":"tmux/server_keys.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ListCommandsRequest.CommandName","product":"core","slug":"tmux-listcommandsrequest-commandname"},{"id":"tmux.ShowMessagesRequest","name":"ShowMessagesRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ShowMessagesRequest selects the target and server information to print. Terminals and Jobs are independent and may both be enabled."},"source":{"file":"tmux/server_keys.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ShowMessagesRequest","product":"core","slug":"tmux-showmessagesrequest"},{"id":"tmux.ShowMessagesRequest.TargetClient","name":"TargetClient","kind":"attribute","modifiers":[],"parent":"tmux.ShowMessagesRequest","signatures":[],"type":"ClientName","doc":{"summary":"TargetClient selects a stable client; zero selects tmux's current client."},"source":{"file":"tmux/server_keys.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ShowMessagesRequest.TargetClient","product":"core","slug":"tmux-showmessagesrequest-targetclient"},{"id":"tmux.ShowMessagesRequest.Terminals","name":"Terminals","kind":"attribute","modifiers":[],"parent":"tmux.ShowMessagesRequest","signatures":[],"type":"bool","doc":{"summary":"Terminals includes terminal capability information."},"source":{"file":"tmux/server_keys.go","line":62,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ShowMessagesRequest.Terminals","product":"core","slug":"tmux-showmessagesrequest-terminals"},{"id":"tmux.ShowMessagesRequest.Jobs","name":"Jobs","kind":"attribute","modifiers":[],"parent":"tmux.ShowMessagesRequest","signatures":[],"type":"bool","doc":{"summary":"Jobs includes job status information."},"source":{"file":"tmux/server_keys.go","line":64,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ShowMessagesRequest.Jobs","product":"core","slug":"tmux-showmessagesrequest-jobs"},{"id":"tmux.Server.BindKey","name":"BindKey","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"BindKeyRequest"}],"returns":"error"}],"doc":{"summary":"BindKey binds Key to Command in a tmux key table. An empty Command creates a no-op binding on tmux 3.3 or newer; tmux 3.2a reports its upstream error. It mutates the table; cancellation does not prove that tmux did not bind Key."},"source":{"file":"tmux/server_keys.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.BindKey","product":"core","slug":"tmux-server-bindkey"},{"id":"tmux.Server.UnbindKey","name":"UnbindKey","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"UnbindKeyRequest"}],"returns":"error"}],"doc":{"summary":"UnbindKey removes one key binding or every binding in a key table. Key and AllKeys must select exactly one target; cancellation does not prove removal did not occur."},"source":{"file":"tmux/server_keys.go","line":103,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.UnbindKey","product":"core","slug":"tmux-server-unbindkey"},{"id":"tmux.Server.ListKeys","name":"ListKeys","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ListKeysRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ListKeys returns an owned snapshot of raw tmux key-binding lines. Format requires tmux 3.7 and follows [UnsupportedPolicy]. tmux 3.7 through 3.7c send a table's sole matching binding to client status and leave stdout empty; this method preserves that upstream and Python behavior. Listing failures remain errors.","body":"On an unused socket, tmux starts an empty server to answer. With the default\nexit-empty setting, that server exits at once and leaves its socket file."},"source":{"file":"tmux/server_keys.go","line":149,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ListKeys","product":"core","slug":"tmux-server-listkeys"},{"id":"tmux.Server.ListCommands","name":"ListCommands","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ListCommandsRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ListCommands returns an owned snapshot of raw tmux command-description lines. A list failure is returned rather than answered with no rows. Like [Server.ListKeys], it answers on a socket holding no server."},"source":{"file":"tmux/server_keys.go","line":189,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ListCommands","product":"core","slug":"tmux-server-listcommands"},{"id":"tmux.Server.ListClients","name":"ListClients","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]string, error)"}],"doc":{"summary":"ListClients returns an owned snapshot of raw tmux client-description lines, the text tmux itself prints. A list failure is returned rather than answered with no rows. [Server.Clients] answers the same question as typed [Client] records and is what most callers want."},"source":{"file":"tmux/server_keys.go","line":211,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ListClients","product":"core","slug":"tmux-server-listclients"},{"id":"tmux.Server.ShowMessages","name":"ShowMessages","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ShowMessagesRequest"}],"returns":"([]string, error)"}],"doc":{"summary":"ShowMessages returns an owned snapshot of the tmux message log, terminal capabilities, job summary, or both terminal and job summaries. A zero TargetClient selects tmux's current client; a list failure is returned rather than answered with no rows."},"source":{"file":"tmux/server_keys.go","line":218,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ShowMessages","product":"core","slug":"tmux-server-showmessages"},{"id":"tmux.Server.ValidateLayouts","name":"ValidateLayouts","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"layouts","type":"iter.Seq2[string, int]"}],"returns":"error"}],"doc":{"summary":"ValidateLayouts checks every layout and its required pane count before any mutation. Nil and empty sequences succeed without I/O unless ctx is canceled. Empty layout strings are ignored. Other entries require at least one pane; classic trees must contain enough leaves. tmux validates JSON contents and geometry when applying the layout.","body":"Names accept unique abbreviations. Version-sensitive names query the selected\ndaemon through this server's transport; only a cold endpoint without a captured\ndaemon identity or control connection uses the configured binary's version.\nPermission, protocol, decode and cancellation errors are preserved.\nValidation errors match\n[ErrInvalidServerCommandRequest]; unavailable presets match [ErrVersionTooLow]."},"source":{"file":"tmux/server_layout.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.ValidateLayouts","product":"core","slug":"tmux-server-validatelayouts"},{"id":"tmux.ErrInvalidServer","name":"ErrInvalidServer","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidServer identifies an operation on an uninitialized [Server]."},"source":{"file":"tmux/server_options.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidServer","product":"core","slug":"tmux-errinvalidserver"},{"id":"tmux.ErrInvalidServerOptions","name":"ErrInvalidServerOptions","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidServerOptions identifies a value that fails [ServerOptions] validation. Executable lookup and working-directory failures retain their own error identities."},"source":{"file":"tmux/server_options.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidServerOptions","product":"core","slug":"tmux-errinvalidserveroptions"},{"id":"tmux.ServerOptions","name":"ServerOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerOptions configures a [Server] without starting tmux. [NewServer] snapshots the effective environment, working directory, and executable; callers retain ownership of every supplied value."},"source":{"file":"tmux/server_options.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions","product":"core","slug":"tmux-serveroptions"},{"id":"tmux.ServerOptions.Binary","name":"Binary","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"string","doc":{"summary":"Binary is the tmux executable name or path. Empty resolves tmux once through the snapshotted PATH. Relative paths resolve against the constructor's working directory. The resolved absolute path is shared by subprocess and control-mode transports."},"source":{"file":"tmux/server_options.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.Binary","product":"core","slug":"tmux-serveroptions-binary"},{"id":"tmux.ServerOptions.SocketName","name":"SocketName","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"string","doc":{"summary":"SocketName selects tmux's named socket. SocketPath takes precedence."},"source":{"file":"tmux/server_options.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.SocketName","product":"core","slug":"tmux-serveroptions-socketname"},{"id":"tmux.ServerOptions.SocketPath","name":"SocketPath","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"string","doc":{"summary":"SocketPath selects an explicit tmux socket path."},"source":{"file":"tmux/server_options.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.SocketPath","product":"core","slug":"tmux-serveroptions-socketpath"},{"id":"tmux.ServerOptions.ConfigFile","name":"ConfigFile","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"string","doc":{"summary":"ConfigFile selects an exact tmux configuration file. Empty lets tmux read its default configuration, so a program inherits whatever the user running it has configured: a base-index other than zero, a prompt that appears in captured pane text, hooks that fire on the sessions this program creates. Point it at a file the program owns, which may be an empty one, when the tmux it drives should not depend on that."},"source":{"file":"tmux/server_options.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.ConfigFile","product":"core","slug":"tmux-serveroptions-configfile"},{"id":"tmux.ServerOptions.Colors","name":"Colors","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"ColorMode","doc":{"summary":"Colors overrides tmux's terminal color capability."},"source":{"file":"tmux/server_options.go","line":42,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.Colors","product":"core","slug":"tmux-serveroptions-colors"},{"id":"tmux.ServerOptions.ProcessEnvironment","name":"ProcessEnvironment","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"[]string","doc":{"summary":"ProcessEnvironment replaces the child process environment. Nil snapshots the current process environment. A non-nil empty slice supplies no caller-provided variables. Execution may add variables required by Go's target platform and a canonical TMUX_TMPDIR that freezes named or default socket selection. Duplicate names retain their last value. Entries containing NUL are rejected except on Plan 9, where NUL separates path-list elements. NewServer clones the slice."},"source":{"file":"tmux/server_options.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.ProcessEnvironment","product":"core","slug":"tmux-serveroptions-processenvironment"},{"id":"tmux.ServerOptions.Unsupported","name":"Unsupported","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"UnsupportedPolicy","doc":{"summary":"Unsupported selects what happens when a request needs an optional tmux capability the running server does not have. The zero value refuses the request; see UnsupportedPolicy."},"source":{"file":"tmux/server_options.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.Unsupported","product":"core","slug":"tmux-serveroptions-unsupported"},{"id":"tmux.ServerOptions.WarningHandler","name":"WarningHandler","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"WarningHandler","doc":{"summary":"WarningHandler receives nonfatal compatibility warnings. Nil discards warnings. See WarningHandler for delivery and concurrency semantics."},"source":{"file":"tmux/server_options.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.WarningHandler","product":"core","slug":"tmux-serveroptions-warninghandler"},{"id":"tmux.ServerOptions.CommandObserver","name":"CommandObserver","kind":"attribute","modifiers":[],"parent":"tmux.ServerOptions","signatures":[],"type":"CommandObserver","doc":{"summary":"CommandObserver receives one record per tmux command run. Nil observes nothing. See CommandObserver for delivery and concurrency semantics."},"source":{"file":"tmux/server_options.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ServerOptions.CommandObserver","product":"core","slug":"tmux-serveroptions-commandobserver"},{"id":"tmux.NewServer","name":"NewServer","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"options","type":"ServerOptions"}],"returns":"(Server, error)"}],"doc":{"summary":"NewServer validates and snapshots one tmux configuration without starting tmux. Empty socket selectors use the endpoint selected by the frozen environment."},"source":{"file":"tmux/server_options.go","line":97,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewServer","product":"core","slug":"tmux-newserver"},{"id":"tmux.Server.WithSocketPath","name":"WithSocketPath","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"path","type":"string"}],"returns":"(Server, error)"}],"doc":{"summary":"WithSocketPath returns a server using path and the receiver's frozen executable, environment, working directory, and server-option policy. Empty clears explicit socket selectors and leaves endpoint selection to tmux. The result has fresh daemon-scoped coordination. A connection-bound receiver is rejected because its transport belongs to the original daemon."},"source":{"file":"tmux/server_options.go","line":106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.WithSocketPath","product":"core","slug":"tmux-server-withsocketpath"},{"id":"tmux.Server.WithProcessEnvironmentValue","name":"WithProcessEnvironmentValue","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(Server, error)"}],"doc":{"summary":"WithProcessEnvironmentValue returns a server whose tmux subprocesses receive name=value while preserving the receiver's frozen executable, configuration, and exact socket endpoint. It does not expose an inherited environment snapshot through [Server.ProcessEnvironment]. The result shares daemon-scoped coordination with the receiver. A connection-bound receiver is rejected."},"source":{"file":"tmux/server_options.go","line":134,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.WithProcessEnvironmentValue","product":"core","slug":"tmux-server-withprocessenvironmentvalue"},{"id":"tmux.ErrVersionQuery","name":"ErrVersionQuery","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrVersionQuery identifies a tmux version probe that produced no usable version. It is matched by errors.Is for VersionQueryError."},"source":{"file":"tmux/server_version.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrVersionQuery","product":"core","slug":"tmux-errversionquery"},{"id":"tmux.ErrVersionTooLow","name":"ErrVersionTooLow","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrVersionTooLow identifies a tmux version below a required feature level. It is matched by errors.Is for VersionTooLowError."},"source":{"file":"tmux/server_version.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrVersionTooLow","product":"core","slug":"tmux-errversiontoolow"},{"id":"tmux.VersionQueryError","name":"VersionQueryError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VersionQueryError reports an unsuccessful tmux version probe. It matches [ErrVersionQuery] through errors.Is; callers can recover its fields with errors.As. Library-created errors retain only the exit code; command arguments and output are omitted, although callers may construct values with other contents."},"source":{"file":"tmux/server_version.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionQueryError","product":"core","slug":"tmux-versionqueryerror"},{"id":"tmux.VersionQueryError.Result","name":"Result","kind":"attribute","modifiers":[],"parent":"tmux.VersionQueryError","signatures":[],"type":"CommandResult","doc":{"summary":"Result contains the library-created error's exit code and no diagnostics."},"source":{"file":"tmux/server_version.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionQueryError.Result","product":"core","slug":"tmux-versionqueryerror-result"},{"id":"tmux.VersionQueryError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.VersionQueryError","signatures":[],"type":"string","doc":{"summary":"Reason describes a malformed successful probe result, when applicable."},"source":{"file":"tmux/server_version.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionQueryError.Reason","product":"core","slug":"tmux-versionqueryerror-reason"},{"id":"tmux.VersionQueryError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.VersionQueryError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/server_version.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionQueryError.Error","product":"core","slug":"tmux-versionqueryerror-error"},{"id":"tmux.VersionQueryError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.VersionQueryError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes VersionQueryError compatible with ErrVersionQuery."},"source":{"file":"tmux/server_version.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionQueryError.Unwrap","product":"core","slug":"tmux-versionqueryerror-unwrap"},{"id":"tmux.VersionTooLowError","name":"VersionTooLowError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VersionTooLowError reports the installed and required tmux feature levels. It matches [ErrVersionTooLow] through errors.Is; callers can recover its fields with errors.As.","body":"Subcommand and Feature are set when one optional capability within a command\nwas refused rather than the command itself, which is what\n[UnsupportedPolicy] governs."},"source":{"file":"tmux/server_version.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionTooLowError","product":"core","slug":"tmux-versiontoolowerror"},{"id":"tmux.VersionTooLowError.Current","name":"Current","kind":"attribute","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[],"type":"Version","doc":{"summary":"Current is the installed tmux feature level."},"source":{"file":"tmux/server_version.go","line":79,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionTooLowError.Current","product":"core","slug":"tmux-versiontoolowerror-current"},{"id":"tmux.VersionTooLowError.Minimum","name":"Minimum","kind":"attribute","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[],"type":"Version","doc":{"summary":"Minimum is the requested minimum feature level."},"source":{"file":"tmux/server_version.go","line":81,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionTooLowError.Minimum","product":"core","slug":"tmux-versiontoolowerror-minimum"},{"id":"tmux.VersionTooLowError.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[],"type":"string","doc":{"summary":"Subcommand names the tmux subcommand whose optional capability was refused. Empty when the command itself is below its floor."},"source":{"file":"tmux/server_version.go","line":84,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionTooLowError.Subcommand","product":"core","slug":"tmux-versiontoolowerror-subcommand"},{"id":"tmux.VersionTooLowError.Feature","name":"Feature","kind":"attribute","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[],"type":"string","doc":{"summary":"Feature names the refused optional capability. Empty when the command itself is below its floor."},"source":{"file":"tmux/server_version.go","line":87,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionTooLowError.Feature","product":"core","slug":"tmux-versiontoolowerror-feature"},{"id":"tmux.VersionTooLowError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/server_version.go","line":91,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionTooLowError.Error","product":"core","slug":"tmux-versiontoolowerror-error"},{"id":"tmux.VersionTooLowError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.VersionTooLowError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes VersionTooLowError compatible with ErrVersionTooLow."},"source":{"file":"tmux/server_version.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionTooLowError.Unwrap","product":"core","slug":"tmux-versiontoolowerror-unwrap"},{"id":"tmux.Server.Version","name":"Version","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Version, error)"}],"doc":{"summary":"Version returns the configured tmux binary's cached version. Failed probes are not cached. A waiting caller can abandon an in-flight shared probe when ctx ends without canceling the caller that owns the probe."},"source":{"file":"tmux/server_version.go","line":152,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Version","product":"core","slug":"tmux-server-version"},{"id":"tmux.Server.RefreshVersion","name":"RefreshVersion","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Version, error)"}],"doc":{"summary":"RefreshVersion invalidates the cached version and probes the binary again. Canceling ctx stops this call's wait; it does not establish whether a probe reached the configured binary."},"source":{"file":"tmux/server_version.go","line":159,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.RefreshVersion","product":"core","slug":"tmux-server-refreshversion"},{"id":"tmux.Server.RequireVersion","name":"RequireVersion","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"minimum","type":"Version"}],"returns":"error"}],"doc":{"summary":"RequireVersion returns a [VersionTooLowError] matching [ErrVersionTooLow] when the configured binary is older than minimum."},"source":{"file":"tmux/server_version.go","line":165,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.RequireVersion","product":"core","slug":"tmux-server-requireversion"},{"id":"tmux.ErrSessionExists","name":"ErrSessionExists","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrSessionExists identifies a named session that was not replaced."},"source":{"file":"tmux/session_lifecycle.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrSessionExists","product":"core","slug":"tmux-errsessionexists"},{"id":"tmux.HasSessionRequest","name":"HasSessionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"HasSessionRequest selects exact or tmux-pattern session matching on tmux 3.2a or later. Its zero value is invalid because Target is required."},"source":{"file":"tmux/session_lifecycle.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.HasSessionRequest","product":"core","slug":"tmux-hassessionrequest"},{"id":"tmux.HasSessionRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.HasSessionRequest","signatures":[],"type":"string","doc":{"summary":"Target is the required session name or tmux session pattern."},"source":{"file":"tmux/session_lifecycle.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.HasSessionRequest.Target","product":"core","slug":"tmux-hassessionrequest-target"},{"id":"tmux.HasSessionRequest.Pattern","name":"Pattern","kind":"attribute","modifiers":[],"parent":"tmux.HasSessionRequest","signatures":[],"type":"bool","doc":{"summary":"Pattern lets tmux interpret Target as a pattern; false requires an exact session name."},"source":{"file":"tmux/session_lifecycle.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.HasSessionRequest.Pattern","product":"core","slug":"tmux-hassessionrequest-pattern"},{"id":"tmux.NewSessionRequest","name":"NewSessionRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NewSessionRequest configures session creation. [Server.NewSession] creates a detached session; [Server.NewSessionConnection] creates one attached to its first control-mode lane. Its zero value uses tmux defaults. Width and Height are either zero or 1 through 65535; KillExisting requires Name. KillExisting may remove a session before a later creation failure.","body":"[Server.NewSession] copies Environment before validation and retains no map\nstorage; concurrent mutation during the copy is unsafe. Foreground-only tmux\nflags are not exposed."},"source":{"file":"tmux/session_lifecycle.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest","product":"core","slug":"tmux-newsessionrequest"},{"id":"tmux.NewSessionRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"string","doc":{"summary":"Name selects the new session name; empty lets tmux generate one."},"source":{"file":"tmux/session_lifecycle.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest.Name","product":"core","slug":"tmux-newsessionrequest-name"},{"id":"tmux.NewSessionRequest.KillExisting","name":"KillExisting","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"bool","doc":{"summary":"KillExisting removes an existing session named Name before creation."},"source":{"file":"tmux/session_lifecycle.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest.KillExisting","product":"core","slug":"tmux-newsessionrequest-killexisting"},{"id":"tmux.NewSessionRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Named-user forms such as ~other are rejected; empty inherits tmux's default."},"source":{"file":"tmux/session_lifecycle.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest.StartDirectory","product":"core","slug":"tmux-newsessionrequest-startdirectory"},{"id":"tmux.NewSessionRequest.WindowName","name":"WindowName","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"string","doc":{"summary":"WindowName names the initial window; empty lets tmux choose."},"source":{"file":"tmux/session_lifecycle.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest.WindowName","product":"core","slug":"tmux-newsessionrequest-windowname"},{"id":"tmux.NewSessionRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"int","doc":{"summary":"Width sets the detached session width; zero lets tmux choose."},"source":{"file":"tmux/session_lifecycle.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest.Width","product":"core","slug":"tmux-newsessionrequest-width"},{"id":"tmux.NewSessionRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"int","doc":{"summary":"Height sets the detached session height; zero lets tmux choose."},"source":{"file":"tmux/session_lifecycle.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest.Height","product":"core","slug":"tmux-newsessionrequest-height"},{"id":"tmux.NewSessionRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order. The map is not retained; nil and an empty map both add no entries."},"source":{"file":"tmux/session_lifecycle.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest.Environment","product":"core","slug":"tmux-newsessionrequest-environment"},{"id":"tmux.NewSessionRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.NewSessionRequest","signatures":[],"type":"string","doc":{"summary":"Command starts the initial pane with this shell command; empty uses tmux's default command."},"source":{"file":"tmux/session_lifecycle.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSessionRequest.Command","product":"core","slug":"tmux-newsessionrequest-command"},{"id":"tmux.Server.HasSession","name":"HasSession","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"HasSessionRequest"}],"returns":"(bool, error)"}],"doc":{"summary":"HasSession reports whether Target selects a session. With Pattern false it compares session names exactly; with Pattern true, tmux may resolve IDs, client TTYs, unique prefixes, or globs. Pattern-mode completed nonzero exits are misses. Exact-name lookup treats [ErrNoServer] as a miss and returns other failures.","body":"Exact-name lookup lists sessions because tmux's exact-match marker still\nresolves identifiers and client TTYs."},"source":{"file":"tmux/session_lifecycle.go","line":128,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.HasSession","product":"core","slug":"tmux-server-hassession"},{"id":"tmux.Server.NewSession","name":"NewSession","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewSessionRequest"}],"returns":"(Session, error)"}],"doc":{"summary":"NewSession creates a detached session, then returns a newly materialized [Session]. It never changes client focus. KillExisting is not rolled back; transport and context failures may be delivery-ambiguous.","body":"The returned record has unmaterialized [Session.Windows] and [Session.Panes]\nrelations. Use the resolvers or [Server.Snapshot] when relations are needed.\n\nIf tmux reports an ID before a transport or refresh failure, the returned\npartial Session contains its [Server] and [SessionID]. Other failures return zero."},"source":{"file":"tmux/session_lifecycle.go","line":184,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.NewSession","product":"core","slug":"tmux-server-newsession"},{"id":"tmux.Session.Rename","name":"Rename","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(Session, error)"}],"doc":{"summary":"Rename changes the receiver session's name and returns a canonical freshly materialized [Session]. If the command succeeds but refresh fails, it returns the receiver with that error. A transport or context error can be delivery-ambiguous; no rollback is attempted. Invalid names are rejected before execution and match [ErrInvalidRequest]."},"source":{"file":"tmux/session_lifecycle.go","line":261,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Rename","product":"core","slug":"tmux-session-rename"},{"id":"tmux.ValidateSessionName","name":"ValidateSessionName","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"name","type":"string"}],"returns":"error"}],"doc":{"summary":"ValidateSessionName reports whether name can be used as a tmux session name. Empty names, the target delimiters '.' and ':', control characters and invalid UTF-8 are rejected."},"source":{"file":"tmux/session_lifecycle.go","line":310,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ValidateSessionName","product":"core","slug":"tmux-validatesessionname"},{"id":"tmux.SelectWindowRequest","name":"SelectWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SelectWindowRequest selects one winlink in a [Session] on tmux 3.2a or later. Its zero value is invalid: exactly one of WindowID and Index is required. That mutual exclusion, stable-ID syntax, and a nonnegative Index are validated before execution. Index is read during the call and is not retained; nil omits it, a nonnil pointer is explicit, and callers must not mutate it concurrently."},"source":{"file":"tmux/session_navigation.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectWindowRequest","product":"core","slug":"tmux-selectwindowrequest"},{"id":"tmux.SelectWindowRequest.WindowID","name":"WindowID","kind":"attribute","modifiers":[],"parent":"tmux.SelectWindowRequest","signatures":[],"type":"WindowID","doc":{"summary":"WindowID selects a stable window linked into the receiver session."},"source":{"file":"tmux/session_navigation.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectWindowRequest.WindowID","product":"core","slug":"tmux-selectwindowrequest-windowid"},{"id":"tmux.SelectWindowRequest.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.SelectWindowRequest","signatures":[],"type":"*int","doc":{"summary":"Index selects a nonnegative winlink index in the receiver session."},"source":{"file":"tmux/session_navigation.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectWindowRequest.Index","product":"core","slug":"tmux-selectwindowrequest-index"},{"id":"tmux.Session.LastWindow","name":"LastWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"LastWindow makes the receiver session's previously selected winlink current and returns that freshly materialized session-specific [Window]. The selection is session-scoped; it does not promise focus for clients attached to other sessions. A transport or context error can be delivery-ambiguous and no rollback is attempted. Command or refresh failure returns a zero Window because this navigation operation cannot identify the selected view reliably without refresh."},"source":{"file":"tmux/session_navigation.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.LastWindow","product":"core","slug":"tmux-session-lastwindow"},{"id":"tmux.Session.NextWindow","name":"NextWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"NextWindow makes the next winlink current in the receiver session and returns that freshly materialized session-specific [Window]. The selection is session-scoped; it does not promise focus for clients attached to other sessions. A transport or context error can be delivery-ambiguous and no rollback is attempted. Command or refresh failure returns a zero Window."},"source":{"file":"tmux/session_navigation.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.NextWindow","product":"core","slug":"tmux-session-nextwindow"},{"id":"tmux.Session.PreviousWindow","name":"PreviousWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"PreviousWindow makes the previous winlink current in the receiver session and returns that freshly materialized session-specific [Window]. The selection is session-scoped; it does not promise focus for clients attached to other sessions. A transport or context error can be delivery-ambiguous and no rollback is attempted. Command or refresh failure returns a zero Window."},"source":{"file":"tmux/session_navigation.go","line":47,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.PreviousWindow","product":"core","slug":"tmux-session-previouswindow"},{"id":"tmux.Session.SelectWindow","name":"SelectWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SelectWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"SelectWindow makes one winlink current in the receiver session and returns that freshly materialized session-specific [Window]. WindowID is combined with the receiver SessionID, because a WindowID alone does not distinguish linked views. The selection is session-scoped; it does not promise focus for clients attached to other sessions.","body":"Command or refresh failures return zero because the selected view cannot be\nidentified without refresh. Transport errors are delivery-ambiguous."},"source":{"file":"tmux/session_navigation.go","line":59,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.SelectWindow","product":"core","slug":"tmux-session-selectwindow"},{"id":"tmux.RunOptions","name":"RunOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RunOptions configures [Session.Run] and [Session.Start]. Its zero value runs the command in a window tmux names, in the session's default directory and environment, and removes that window once the command has finished."},"source":{"file":"tmux/session_run.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunOptions","product":"core","slug":"tmux-runoptions"},{"id":"tmux.RunOptions.WindowName","name":"WindowName","kind":"attribute","modifiers":[],"parent":"tmux.RunOptions","signatures":[],"type":"string","doc":{"summary":"WindowName names the window the command runs in; empty lets tmux choose."},"source":{"file":"tmux/session_run.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunOptions.WindowName","product":"core","slug":"tmux-runoptions-windowname"},{"id":"tmux.RunOptions.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.RunOptions","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user; empty inherits the session's default."},"source":{"file":"tmux/session_run.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunOptions.StartDirectory","product":"core","slug":"tmux-runoptions-startdirectory"},{"id":"tmux.RunOptions.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.RunOptions","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is added to the command's environment. The map is not retained."},"source":{"file":"tmux/session_run.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunOptions.Environment","product":"core","slug":"tmux-runoptions-environment"},{"id":"tmux.RunOptions.Keep","name":"Keep","kind":"attribute","modifiers":[],"parent":"tmux.RunOptions","signatures":[],"type":"bool","doc":{"summary":"Keep leaves the finished window in place, showing what the command printed, instead of removing it."},"source":{"file":"tmux/session_run.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunOptions.Keep","product":"core","slug":"tmux-runoptions-keep"},{"id":"tmux.ErrOutcomeUnrecorded","name":"ErrOutcomeUnrecorded","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrOutcomeUnrecorded reports that a command's pane is dead while tmux has not recorded how the command ended, which it does by reaping the command's process. tmux is known to leave a pane in that state indefinitely, so this is reported rather than waited out, and rather than passed off as a zero exit status that would call a failed command successful."},"source":{"file":"tmux/session_run.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrOutcomeUnrecorded","product":"core","slug":"tmux-erroutcomeunrecorded"},{"id":"tmux.RunResult","name":"RunResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RunResult reports how a command finished and what its terminal showed."},"source":{"file":"tmux/session_run.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunResult","product":"core","slug":"tmux-runresult"},{"id":"tmux.RunResult.Status","name":"Status","kind":"attribute","modifiers":[],"parent":"tmux.RunResult","signatures":[],"type":"int","doc":{"summary":"Status is the command's exit status. It is zero when Signal is set."},"source":{"file":"tmux/session_run.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunResult.Status","product":"core","slug":"tmux-runresult-status"},{"id":"tmux.RunResult.Signal","name":"Signal","kind":"attribute","modifiers":[],"parent":"tmux.RunResult","signatures":[],"type":"string","doc":{"summary":"Signal names the signal that ended the command, when one did. It is empty before tmux 3.3, which reports no signal for a dead pane."},"source":{"file":"tmux/session_run.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunResult.Signal","product":"core","slug":"tmux-runresult-signal"},{"id":"tmux.RunResult.Lines","name":"Lines","kind":"attribute","modifiers":[],"parent":"tmux.RunResult","signatures":[],"type":"[]string","doc":{"summary":"Lines is what the terminal showed when the command finished, without the blank lines tmux pads a screen with."},"source":{"file":"tmux/session_run.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunResult.Lines","product":"core","slug":"tmux-runresult-lines"},{"id":"tmux.RunResult.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.RunResult","signatures":[],"type":"PaneID","doc":{"summary":"Pane is the pane the command ran in. It is live only when the run kept its window."},"source":{"file":"tmux/session_run.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RunResult.Pane","product":"core","slug":"tmux-runresult-pane"},{"id":"tmux.Session.Run","name":"Run","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"command","type":"string"},{"name":"options","type":"RunOptions"}],"returns":"(RunResult, error)"}],"doc":{"summary":"Run starts command in a new window of this session, waits for it to finish, and reports its exit status and what its terminal showed. It is [os/exec] for a program that needs a terminal: the command runs with a tty, so it sees isatty, colour, and a width, and what comes back is the screen tmux rendered rather than the bytes the program wrote.","body":"A nonzero status is a result, not an error; the error reports what tmux\ncould not do. The wait is tmux's own signal, backed by a liveness check that\nwidens from a quarter second in case that signal is lost: it needs no tmux\nbinary on the command's PATH and returns as the process exits. A command that never\nexits holds Run until ctx ends. On error, Run removes its window regardless\nof [RunOptions.Keep], since Run gives the caller no other chance to retry or\nclean up; a bare [Session.Start] followed by [Running.Wait] leaves that\nchoice to the caller instead. [Server.RunShell] runs a command with no pane\nat all."},"source":{"file":"tmux/session_run.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Run","product":"core","slug":"tmux-session-run"},{"id":"tmux.Session.Start","name":"Start","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"command","type":"string"},{"name":"options","type":"RunOptions"}],"returns":"(running *Running, err error)"}],"doc":{"summary":"Start runs command in a new window of this session and returns once it is under way, without waiting for it to finish. The returned [Running] reports the pane it runs in and blocks on demand: [Running.Wait] waits for the exit status and screen [Session.Run] would have returned, and [Running.Kill] stops the command. Options are exactly Run's.","body":"Before tmux 3.7, Start attempts to install an output pipe running cat\nunless the pane already has a pipe; a failed attempt only forfeits that\ncompatibility help. [Running.Wait] stops a pipe Start installed once the\noutcome is read, whether or not Keep leaves the window itself in place.\n\nIf Wait is never called, the window Start created is never removed."},"source":{"file":"tmux/session_run.go","line":103,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.Start","product":"core","slug":"tmux-session-start"},{"id":"tmux.Running","name":"Running","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Running is a command started by [Session.Start]: a real process, already under way, in a pane of its own. [Running.Pane] exposes that pane so its output can be streamed with [Pane.OpenObservation] or typed into with [Pane.Writer] while the command runs; [Running.Wait] and [Running.Kill] wait for and stop it. A line printed with nothing separating it from the command's own exit can race tmux's control-mode notification of it and never reach [PaneObservation.Reader]; [RunResult.Lines] from Wait, a plain screen capture rather than that notification stream, always has it."},"source":{"file":"tmux/session_run.go","line":192,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Running","product":"core","slug":"tmux-running"},{"id":"tmux.Running.Pane","name":"Pane","kind":"method","modifiers":[],"parent":"tmux.Running","signatures":[{"params":[],"returns":"Pane"}],"doc":{"summary":"Pane returns the pane the command runs in, materialized immediately after Start returned. Like any materialized record it does not refresh itself; a call after Wait or Kill may no longer describe a live pane."},"source":{"file":"tmux/session_run.go","line":218,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Running.Pane","product":"core","slug":"tmux-running-pane"},{"id":"tmux.Running.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"tmux.Running","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(RunResult, error)"}],"doc":{"summary":"Wait blocks until the command exits, on tmux's own wait-for signal backed by a widening liveness check, and reports its exit status and what its terminal showed. It removes the window Start created unless [RunOptions.Keep] was set. A command whose process tmux never reaps has no outcome to report, and Wait ends with [ErrOutcomeUnrecorded] rather than the zero status that would make a failed command look successful.","body":"Wait may be called more than once and concurrently; every call observes the\nsame completion. The outcome is read once, as soon as any call sees the\ncommand end, on a context no caller's cancellation reaches, because from\nthen on it belongs to every caller. A call whose context ends first reports\nthat context and leaves the window alone; a later call gets the outcome."},"source":{"file":"tmux/session_run.go","line":234,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Running.Wait","product":"core","slug":"tmux-running-wait"},{"id":"tmux.Running.StreamTo","name":"StreamTo","kind":"method","modifiers":[],"parent":"tmux.Running","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"destination","type":"io.Writer"}],"returns":"(RunResult, error)"}],"doc":{"summary":"StreamTo copies what the command prints into destination as it prints it and then reports how it ended, so following a command and collecting its outcome are one blocking call rather than a goroutine the caller writes. It returns exactly what [Running.Wait] returns and, like Wait, removes the window unless [RunOptions.Keep] was set. destination is written only by this call, so it needs no synchronization of its own, and [Running.Kill] may be called from another goroutine while it runs.","body":"The stream is what tmux pushed, which is not quite everything: output the\ncommand printed before StreamTo opened its observation may or may not be in\nit, and tmux can drop a line printed with nothing between it and the\ncommand's exit. [RunResult.Lines] is a screen capture rather than a\nnotification stream and remains the authoritative record of what the command\nshowed. Streaming needs a control client, which a [Connection]-bound value\ndoes not have, so it returns [ErrConnectionRequiresProcess] there; Wait alone\ndoes not."},"source":{"file":"tmux/session_run.go","line":540,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Running.StreamTo","product":"core","slug":"tmux-running-streamto"},{"id":"tmux.Running.Kill","name":"Kill","kind":"method","modifiers":[],"parent":"tmux.Running","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Kill asks the tmux server to send SIGKILL to the process group running the command. It does not wait for the process to stop; call Wait to observe the resulting status or signal.","body":"Kill runs through [Server.RunShell] with the pane as its target, so tmux\nresolves the process group id itself, at the moment it runs, on whatever\nhost the server is on, rather than trusting a process id this program read\nearlier. A pane that no longer exists makes that id resolve empty and Kill\na no-op; Kill reports only whether tmux could dispatch the request, not\nwhether a process still existed to receive it."},"source":{"file":"tmux/session_run.go","line":592,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Running.Kill","product":"core","slug":"tmux-running-kill"},{"id":"tmux.ErrMalformedSnapshot","name":"ErrMalformedSnapshot","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMalformedSnapshot identifies invalid required fields in decoded rows. SnapshotDecodeError matches it through errors.Is."},"source":{"file":"tmux/snapshot.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrMalformedSnapshot","product":"core","slug":"tmux-errmalformedsnapshot"},{"id":"tmux.ErrSnapshotAmbiguous","name":"ErrSnapshotAmbiguous","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrSnapshotAmbiguous identifies a point lookup with multiple matching views. SnapshotLookupError matches it through errors.Is."},"source":{"file":"tmux/snapshot.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrSnapshotAmbiguous","product":"core","slug":"tmux-errsnapshotambiguous"},{"id":"tmux.SnapshotDecodeError","name":"SnapshotDecodeError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SnapshotDecodeError identifies one malformed decoded list row. It matches [ErrMalformedSnapshot] through errors.Is; callers can recover its redacted location fields with errors.As."},"source":{"file":"tmux/snapshot.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotDecodeError","product":"core","slug":"tmux-snapshotdecodeerror"},{"id":"tmux.SnapshotDecodeError.Object","name":"Object","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"string","doc":{"summary":"Object names the tmux object whose listing contained the record."},"source":{"file":"tmux/snapshot.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotDecodeError.Object","product":"core","slug":"tmux-snapshotdecodeerror-object"},{"id":"tmux.SnapshotDecodeError.Record","name":"Record","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"int","doc":{"summary":"Record is the one-based physical record number in that listing."},"source":{"file":"tmux/snapshot.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotDecodeError.Record","product":"core","slug":"tmux-snapshotdecodeerror-record"},{"id":"tmux.SnapshotDecodeError.Field","name":"Field","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"string","doc":{"summary":"Field names the required format field that could not be decoded."},"source":{"file":"tmux/snapshot.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotDecodeError.Field","product":"core","slug":"tmux-snapshotdecodeerror-field"},{"id":"tmux.SnapshotDecodeError.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"string","doc":{"summary":"Value is redacted for library-created errors because snapshot fields may contain pane output, commands, paths, or other caller data."},"source":{"file":"tmux/snapshot.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotDecodeError.Value","product":"core","slug":"tmux-snapshotdecodeerror-value"},{"id":"tmux.SnapshotDecodeError.Reason","name":"Reason","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[],"type":"string","doc":{"summary":"Reason describes why the field was malformed."},"source":{"file":"tmux/snapshot.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotDecodeError.Reason","product":"core","slug":"tmux-snapshotdecodeerror-reason"},{"id":"tmux.SnapshotDecodeError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/snapshot.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotDecodeError.Error","product":"core","slug":"tmux-snapshotdecodeerror-error"},{"id":"tmux.SnapshotDecodeError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.SnapshotDecodeError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes SnapshotDecodeError compatible with ErrMalformedSnapshot."},"source":{"file":"tmux/snapshot.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotDecodeError.Unwrap","product":"core","slug":"tmux-snapshotdecodeerror-unwrap"},{"id":"tmux.SnapshotLookupError","name":"SnapshotLookupError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SnapshotLookupError reports the cardinality of an unsuccessful point lookup. It matches [ErrNotFound] or [ErrSnapshotAmbiguous] through errors.Is; callers can recover its target and count with errors.As."},"source":{"file":"tmux/snapshot.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotLookupError","product":"core","slug":"tmux-snapshotlookuperror"},{"id":"tmux.SnapshotLookupError.Object","name":"Object","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[],"type":"string","doc":{"summary":"Object names the requested snapshot object kind."},"source":{"file":"tmux/snapshot.go","line":58,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotLookupError.Object","product":"core","slug":"tmux-snapshotlookuperror-object"},{"id":"tmux.SnapshotLookupError.Identifier","name":"Identifier","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[],"type":"string","doc":{"summary":"Identifier is the requested stable identifier."},"source":{"file":"tmux/snapshot.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotLookupError.Identifier","product":"core","slug":"tmux-snapshotlookuperror-identifier"},{"id":"tmux.SnapshotLookupError.Matches","name":"Matches","kind":"attribute","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[],"type":"int","doc":{"summary":"Matches is the number of matching materialized views."},"source":{"file":"tmux/snapshot.go","line":62,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotLookupError.Matches","product":"core","slug":"tmux-snapshotlookuperror-matches"},{"id":"tmux.SnapshotLookupError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/snapshot.go","line":66,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotLookupError.Error","product":"core","slug":"tmux-snapshotlookuperror-error"},{"id":"tmux.SnapshotLookupError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.SnapshotLookupError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap classifies the failed lookup by cardinality."},"source":{"file":"tmux/snapshot.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SnapshotLookupError.Unwrap","product":"core","slug":"tmux-snapshotlookuperror-unwrap"},{"id":"tmux.Snapshot","name":"Snapshot","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Snapshot is an immutable, observational view of one tmux server. It is normally returned by [Server.Snapshot]. Its zero value has a zero [Version], a zero [Server], non-nil empty collection slices, and not-found point lookups. Accessors never query tmux; returned slices are newly allocated and their contained records are shallow copies."},"source":{"file":"tmux/snapshot.go","line":92,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot","product":"core","slug":"tmux-snapshot"},{"id":"tmux.Snapshot.Version","name":"Version","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"Version"}],"doc":{"summary":"Version returns the tmux version that selected this snapshot's format fields. The zero Snapshot returns a zero Version."},"source":{"file":"tmux/snapshot.go","line":148,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.Version","product":"core","slug":"tmux-snapshot-version"},{"id":"tmux.Snapshot.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"Server"}],"doc":{"summary":"Server returns the configured handle that produced this snapshot. The zero Snapshot returns a zero Server."},"source":{"file":"tmux/snapshot.go","line":157,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.Server","product":"core","slug":"tmux-snapshot-server"},{"id":"tmux.Snapshot.Sessions","name":"Sessions","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"[]Session"}],"doc":{"summary":"Sessions returns a newly allocated shallow copy of materialized sessions. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":166,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.Sessions","product":"core","slug":"tmux-snapshot-sessions"},{"id":"tmux.Snapshot.Windows","name":"Windows","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"[]Window"}],"doc":{"summary":"Windows returns a newly allocated shallow copy with one view per winlink. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":175,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.Windows","product":"core","slug":"tmux-snapshot-windows"},{"id":"tmux.Snapshot.Panes","name":"Panes","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"[]Pane"}],"doc":{"summary":"Panes returns a newly allocated shallow copy of pane views for every winlink. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":184,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.Panes","product":"core","slug":"tmux-snapshot-panes"},{"id":"tmux.Snapshot.Clients","name":"Clients","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"[]Client"}],"doc":{"summary":"Clients returns a newly allocated shallow copy of materialized clients. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":193,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.Clients","product":"core","slug":"tmux-snapshot-clients"},{"id":"tmux.Snapshot.SessionsSeq","name":"SessionsSeq","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"iter.Seq[Session]"}],"doc":{"summary":"SessionsSeq returns an iterator over materialized session values. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":202,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.SessionsSeq","product":"core","slug":"tmux-snapshot-sessionsseq"},{"id":"tmux.Snapshot.WindowsSeq","name":"WindowsSeq","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"iter.Seq[Window]"}],"doc":{"summary":"WindowsSeq returns an iterator over materialized winlink values. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":211,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.WindowsSeq","product":"core","slug":"tmux-snapshot-windowsseq"},{"id":"tmux.Snapshot.PanesSeq","name":"PanesSeq","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"iter.Seq[Pane]"}],"doc":{"summary":"PanesSeq returns an iterator over materialized pane-view values. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":220,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.PanesSeq","product":"core","slug":"tmux-snapshot-panesseq"},{"id":"tmux.Snapshot.ClientsSeq","name":"ClientsSeq","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[],"returns":"iter.Seq[Client]"}],"doc":{"summary":"ClientsSeq returns an iterator over materialized client values. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":229,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.ClientsSeq","product":"core","slug":"tmux-snapshot-clientsseq"},{"id":"tmux.Snapshot.SessionByID","name":"SessionByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"SessionID"}],"returns":"(Session, error)"}],"doc":{"summary":"SessionByID returns the sole session view with id. It never queries tmux and returns a [SnapshotLookupError] matching [ErrNotFound] otherwise."},"source":{"file":"tmux/snapshot.go","line":238,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.SessionByID","product":"core","slug":"tmux-snapshot-sessionbyid"},{"id":"tmux.Snapshot.WindowByID","name":"WindowByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"WindowID"}],"returns":"(Window, error)"}],"doc":{"summary":"WindowByID returns the sole winlink view with id. Linked sessions can make an ID ambiguous, so it can return a [SnapshotLookupError] matching [ErrSnapshotAmbiguous]. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":248,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.WindowByID","product":"core","slug":"tmux-snapshot-windowbyid"},{"id":"tmux.Snapshot.WindowsByID","name":"WindowsByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"WindowID"}],"returns":"[]Window"}],"doc":{"summary":"WindowsByID returns newly allocated shallow copies of every winlink view with id. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":257,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.WindowsByID","product":"core","slug":"tmux-snapshot-windowsbyid"},{"id":"tmux.Snapshot.PaneByID","name":"PaneByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"PaneID"}],"returns":"(Pane, error)"}],"doc":{"summary":"PaneByID returns the sole pane view with id. Linked-session views can make an ID ambiguous, so it can return a [SnapshotLookupError] matching [ErrSnapshotAmbiguous]. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":267,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.PaneByID","product":"core","slug":"tmux-snapshot-panebyid"},{"id":"tmux.Snapshot.PanesByID","name":"PanesByID","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"id","type":"PaneID"}],"returns":"[]Pane"}],"doc":{"summary":"PanesByID returns newly allocated shallow copies of every pane view with id. It never queries tmux."},"source":{"file":"tmux/snapshot.go","line":276,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.PanesByID","product":"core","slug":"tmux-snapshot-panesbyid"},{"id":"tmux.Snapshot.ClientByName","name":"ClientByName","kind":"method","modifiers":[],"parent":"tmux.Snapshot","signatures":[{"params":[{"name":"name","type":"ClientName"}],"returns":"(Client, error)"}],"doc":{"summary":"ClientByName returns the sole client view with name. It never queries tmux and returns a [SnapshotLookupError] matching [ErrNotFound] or [ErrSnapshotAmbiguous] when cardinality is not one."},"source":{"file":"tmux/snapshot.go","line":286,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Snapshot.ClientByName","product":"core","slug":"tmux-snapshot-clientbyname"},{"id":"tmux.Server.Snapshot","name":"Snapshot","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Snapshot, error)"}],"doc":{"summary":"Snapshot materializes sessions, winlinks, panes, and clients. Its sequential commands produce an observationally consistent result, not an atomic transaction. Failures remain errors rather than empty snapshots; cancellation may occur after earlier listings completed.","body":"Identity probes reject a daemon replacement during subprocess collection.\nA connection is already bound to the exact daemon and skips the closing\nprobe; the opening probe still selects version-specific fields."},"source":{"file":"tmux/snapshot_capture.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.Snapshot","product":"core","slug":"tmux-server-snapshot"},{"id":"tmux.SocketSelection","name":"SocketSelection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SocketSelection describes the Unix filesystem endpoint selected by a [Server]. It does not report whether a server is listening there or whether tmux would accept the named-socket directory's ownership and permissions."},"source":{"file":"tmux/socket_selection.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SocketSelection","product":"core","slug":"tmux-socketselection"},{"id":"tmux.SocketSelection.Path","name":"Path","kind":"attribute","modifiers":[],"parent":"tmux.SocketSelection","signatures":[],"type":"string","doc":{"summary":"Path is the absolute path selected by the frozen socket options, environment, and working directory."},"source":{"file":"tmux/socket_selection.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SocketSelection.Path","product":"core","slug":"tmux-socketselection-path"},{"id":"tmux.SocketSelection.NamedDirectory","name":"NamedDirectory","kind":"attribute","modifiers":[],"parent":"tmux.SocketSelection","signatures":[],"type":"string","doc":{"summary":"NamedDirectory is the directory tmux uses for named and default sockets. It can differ from Path's directory when -S or TMUX selects another path."},"source":{"file":"tmux/socket_selection.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SocketSelection.NamedDirectory","product":"core","slug":"tmux-socketselection-nameddirectory"},{"id":"tmux.Server.SocketSelection","name":"SocketSelection","kind":"method","modifiers":[],"parent":"tmux.Server","signatures":[{"params":[],"returns":"(SocketSelection, error)"}],"doc":{"summary":"SocketSelection returns tmux's -S, -L, TMUX, and default-socket precedence snapshotted by [NewServer]. It does not start tmux or require the selected socket to exist."},"source":{"file":"tmux/socket_selection.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Server.SocketSelection","product":"core","slug":"tmux-server-socketselection"},{"id":"tmux.ErrInvalidSparseIndex","name":"ErrInvalidSparseIndex","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidSparseIndex identifies a negative or overflowing sparse index."},"source":{"file":"tmux/sparse_array.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidSparseIndex","product":"core","slug":"tmux-errinvalidsparseindex"},{"id":"tmux.ErrDuplicateSparseIndex","name":"ErrDuplicateSparseIndex","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrDuplicateSparseIndex identifies repeated constructor indices."},"source":{"file":"tmux/sparse_array.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrDuplicateSparseIndex","product":"core","slug":"tmux-errduplicatesparseindex"},{"id":"tmux.SparseEntry","name":"SparseEntry","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SparseEntry is one indexed [SparseArray] value."},"source":{"file":"tmux/sparse_array.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseEntry","product":"core","slug":"tmux-sparseentry"},{"id":"tmux.SparseEntry.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.SparseEntry","signatures":[],"type":"int","doc":{"summary":"Index is the nonnegative sparse-array index."},"source":{"file":"tmux/sparse_array.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseEntry.Index","product":"core","slug":"tmux-sparseentry-index"},{"id":"tmux.SparseEntry.Value","name":"Value","kind":"attribute","modifiers":[],"parent":"tmux.SparseEntry","signatures":[],"type":"T","doc":{"summary":"Value is the value stored at Index."},"source":{"file":"tmux/sparse_array.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseEntry.Value","product":"core","slug":"tmux-sparseentry-value"},{"id":"tmux.SparseArray","name":"SparseArray","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SparseArray stores values at sorted, nonnegative indices. Its zero value is an empty array. Constructors and functional updates own their entry slices; copies of reference-bearing T values remain shallow."},"source":{"file":"tmux/sparse_array.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray","product":"core","slug":"tmux-sparsearray"},{"id":"tmux.NewSparseArray","name":"NewSparseArray","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"entries","type":"SparseEntry[T]"}],"returns":"(SparseArray[T], error)","typeParams":["T any"]}],"doc":{"summary":"NewSparseArray builds an array from entries, sorting them by index. It returns errors matching [ErrInvalidSparseIndex] or [ErrDuplicateSparseIndex] for negative, overflowing, or duplicate indices."},"source":{"file":"tmux/sparse_array.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewSparseArray","product":"core","slug":"tmux-newsparsearray"},{"id":"tmux.SparseArray.Get","name":"Get","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[{"name":"index","type":"int"}],"returns":"(T, bool)"}],"doc":{"summary":"Get returns the value at index and reports whether it is present. A missing index, including a sparse hole, returns the zero value and false."},"source":{"file":"tmux/sparse_array.go","line":66,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray.Get","product":"core","slug":"tmux-sparsearray-get"},{"id":"tmux.SparseArray.Len","name":"Len","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Len returns the number of present entries, not the highest index."},"source":{"file":"tmux/sparse_array.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray.Len","product":"core","slug":"tmux-sparsearray-len"},{"id":"tmux.SparseArray.Indices","name":"Indices","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"[]int"}],"doc":{"summary":"Indices returns a fresh slice of present indices in ascending order."},"source":{"file":"tmux/sparse_array.go","line":81,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray.Indices","product":"core","slug":"tmux-sparsearray-indices"},{"id":"tmux.SparseArray.Entries","name":"Entries","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"[]SparseEntry[T]"}],"doc":{"summary":"Entries returns a fresh shallow copy in ascending index order."},"source":{"file":"tmux/sparse_array.go","line":90,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray.Entries","product":"core","slug":"tmux-sparsearray-entries"},{"id":"tmux.SparseArray.Values","name":"Values","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"[]T"}],"doc":{"summary":"Values returns a fresh shallow slice in ascending index order."},"source":{"file":"tmux/sparse_array.go","line":95,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray.Values","product":"core","slug":"tmux-sparsearray-values"},{"id":"tmux.SparseArray.All","name":"All","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[],"returns":"iter.Seq2[int, T]"}],"doc":{"summary":"All returns an iterator over indices and values in ascending index order."},"source":{"file":"tmux/sparse_array.go","line":104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray.All","product":"core","slug":"tmux-sparsearray-all"},{"id":"tmux.SparseArray.With","name":"With","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[{"name":"index","type":"int"},{"name":"value","type":"T"}],"returns":"(SparseArray[T], error)"}],"doc":{"summary":"With returns a copy with value inserted or replaced at index. It leaves the receiver unchanged and returns an error matching [ErrInvalidSparseIndex] for a negative index."},"source":{"file":"tmux/sparse_array.go","line":117,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray.With","product":"core","slug":"tmux-sparsearray-with"},{"id":"tmux.SparseArray.Append","name":"Append","kind":"method","modifiers":[],"parent":"tmux.SparseArray","signatures":[{"params":[{"name":"value","type":"T"}],"returns":"(SparseArray[T], error)"}],"doc":{"summary":"Append returns a copy with value stored after the highest present index. It leaves the receiver unchanged and returns an error matching [ErrInvalidSparseIndex] when that index overflows."},"source":{"file":"tmux/sparse_array.go","line":136,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SparseArray.Append","product":"core","slug":"tmux-sparsearray-append"},{"id":"tmux.ErrMissingTarget","name":"ErrMissingTarget","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMissingTarget identifies an operation on a zero-value model identity."},"source":{"file":"tmux/target.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrMissingTarget","product":"core","slug":"tmux-errmissingtarget"},{"id":"tmux.ErrInvalidTarget","name":"ErrInvalidTarget","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidTarget identifies a malformed stable tmux identifier. It is matched by errors.Is for TargetError."},"source":{"file":"tmux/target.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidTarget","product":"core","slug":"tmux-errinvalidtarget"},{"id":"tmux.TargetError","name":"TargetError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"TargetError reports a malformed stable identifier before command execution. It matches [ErrInvalidTarget] through errors.Is; callers can recover Object and Target with errors.As."},"source":{"file":"tmux/target.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TargetError","product":"core","slug":"tmux-targeterror"},{"id":"tmux.TargetError.Object","name":"Object","kind":"attribute","modifiers":[],"parent":"tmux.TargetError","signatures":[],"type":"string","doc":{"summary":"Object names the tmux object kind whose target was validated."},"source":{"file":"tmux/target.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TargetError.Object","product":"core","slug":"tmux-targeterror-object"},{"id":"tmux.TargetError.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.TargetError","signatures":[],"type":"string","doc":{"summary":"Target is the submitted target text."},"source":{"file":"tmux/target.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TargetError.Target","product":"core","slug":"tmux-targeterror-target"},{"id":"tmux.TargetError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.TargetError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/target.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TargetError.Error","product":"core","slug":"tmux-targeterror-error"},{"id":"tmux.TargetError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.TargetError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes TargetError compatible with ErrInvalidTarget."},"source":{"file":"tmux/target.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.TargetError.Unwrap","product":"core","slug":"tmux-targeterror-unwrap"},{"id":"tmux.MissingTargetError","name":"MissingTargetError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MissingTargetError reports an operation attempted on a zero-value model identity. It matches [ErrMissingTarget] through errors.Is; callers can recover Object with errors.As.","body":"A relation accessor such as [Session.ActiveWindow] or [Session.Windows]\nreturns ok false rather than a value with no id, and a creation call such\nas [Server.NewSession] carries no relations at all - so using a discarded\nor freshly created value's zero-value fields reaches this error on the\nfirst operation. Resolve live state with a Resolve* method or a fresh\n[Server.Snapshot] instead."},"source":{"file":"tmux/target.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MissingTargetError","product":"core","slug":"tmux-missingtargeterror"},{"id":"tmux.MissingTargetError.Object","name":"Object","kind":"attribute","modifiers":[],"parent":"tmux.MissingTargetError","signatures":[],"type":"string","doc":{"summary":"Object names the tmux object kind with no id: \"session\", \"window\", \"pane\", or \"client\"."},"source":{"file":"tmux/target.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MissingTargetError.Object","product":"core","slug":"tmux-missingtargeterror-object"},{"id":"tmux.MissingTargetError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.MissingTargetError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/target.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MissingTargetError.Error","product":"core","slug":"tmux-missingtargeterror-error"},{"id":"tmux.MissingTargetError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.MissingTargetError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes MissingTargetError compatible with ErrMissingTarget."},"source":{"file":"tmux/target.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MissingTargetError.Unwrap","product":"core","slug":"tmux-missingtargeterror-unwrap"},{"id":"tmux.MinimumSupportedVersion","name":"MinimumSupportedVersion","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"MinimumSupportedVersion is the oldest tmux feature level supported by this package."},"source":{"file":"tmux/version.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MinimumSupportedVersion","product":"core","slug":"tmux-minimumsupportedversion"},{"id":"tmux.MinimumConnectionVersion","name":"MinimumConnectionVersion","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"MinimumConnectionVersion is the oldest tmux feature level that supports terminal Connection ownership. Later releases may strengthen individual lifecycle guarantees without changing this floor."},"source":{"file":"tmux/version.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MinimumConnectionVersion","product":"core","slug":"tmux-minimumconnectionversion"},{"id":"tmux.MaximumTestedVersion","name":"MaximumTestedVersion","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"MaximumTestedVersion is the newest numbered tmux feature level covered by this package's tests. The matrix also runs 3.8-rc2, which is a release candidate rather than a numbered feature level, so it does not raise this."},"source":{"file":"tmux/version.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MaximumTestedVersion","product":"core","slug":"tmux-maximumtestedversion"},{"id":"tmux.ErrInvalidVersion","name":"ErrInvalidVersion","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidVersion identifies malformed tmux version tokens. It is matched by errors.Is for VersionError."},"source":{"file":"tmux/version.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ErrInvalidVersion","product":"core","slug":"tmux-errinvalidversion"},{"id":"tmux.VersionError","name":"VersionError","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"VersionError reports a tmux version token that cannot be parsed. It matches [ErrInvalidVersion] through errors.Is; callers can recover Token with errors.As."},"source":{"file":"tmux/version.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionError","product":"core","slug":"tmux-versionerror"},{"id":"tmux.VersionError.Token","name":"Token","kind":"attribute","modifiers":[],"parent":"tmux.VersionError","signatures":[],"type":"string","doc":{"summary":"Token is the rejected tmux version text."},"source":{"file":"tmux/version.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionError.Token","product":"core","slug":"tmux-versionerror-token"},{"id":"tmux.VersionError.Error","name":"Error","kind":"method","modifiers":[],"parent":"tmux.VersionError","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"Error implements error."},"source":{"file":"tmux/version.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionError.Error","product":"core","slug":"tmux-versionerror-error"},{"id":"tmux.VersionError.Unwrap","name":"Unwrap","kind":"method","modifiers":[],"parent":"tmux.VersionError","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Unwrap makes VersionError compatible with ErrInvalidVersion."},"source":{"file":"tmux/version.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.VersionError.Unwrap","product":"core","slug":"tmux-versionerror-unwrap"},{"id":"tmux.Version","name":"Version","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Version is a parsed tmux version that preserves its original token. Obtain a value with [ParseVersion], [Server.Version], or [Snapshot.Version]. Its zero value has no feature level and is useful only as an absent version. Parsed OpenBSD base-system tokens also have no feature level until [Server.Version] probes the configured binary's commands."},"source":{"file":"tmux/version.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Version","product":"core","slug":"tmux-version"},{"id":"tmux.ParseVersion","name":"ParseVersion","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"raw","type":"string"}],"returns":"(Version, error)"}],"doc":{"summary":"ParseVersion parses a raw tmux version token. It returns a [VersionError] matching [ErrInvalidVersion] when the token cannot be parsed."},"source":{"file":"tmux/version.go","line":73,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ParseVersion","product":"core","slug":"tmux-parseversion"},{"id":"tmux.Version.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String returns the original tmux version token."},"source":{"file":"tmux/version.go","line":144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Version.String","product":"core","slug":"tmux-version-string"},{"id":"tmux.Version.Major","name":"Major","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Major returns the capability-level major component. Development tokens use the latest tested feature core. Unprobed OpenBSD base-system tokens return zero."},"source":{"file":"tmux/version.go","line":151,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Version.Major","product":"core","slug":"tmux-version-major"},{"id":"tmux.Version.Minor","name":"Minor","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Minor returns the capability-level minor component, or zero when absent. Development tokens use the latest tested feature core. Unprobed OpenBSD base-system tokens return zero."},"source":{"file":"tmux/version.go","line":158,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Version.Minor","product":"core","slug":"tmux-version-minor"},{"id":"tmux.Version.Patch","name":"Patch","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[],"returns":"int"}],"doc":{"summary":"Patch returns the capability-level patch component, or zero when absent."},"source":{"file":"tmux/version.go","line":163,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Version.Patch","product":"core","slug":"tmux-version-patch"},{"id":"tmux.Version.Compare","name":"Compare","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[{"name":"other","type":"Version"}],"returns":"int"}],"doc":{"summary":"Compare compares numeric feature levels and returns -1, 0, or 1. Release qualifiers other than master do not change the feature level."},"source":{"file":"tmux/version.go","line":169,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Version.Compare","product":"core","slug":"tmux-version-compare"},{"id":"tmux.Version.CompareRelease","name":"CompareRelease","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[{"name":"other","type":"Version"}],"returns":"int"}],"doc":{"summary":"CompareRelease compares raw release suffixes using libtmux's legacy order. Use Compare for feature gates, where point-release suffixes intentionally share one capability level."},"source":{"file":"tmux/version.go","line":186,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Version.CompareRelease","product":"core","slug":"tmux-version-comparerelease"},{"id":"tmux.Version.AtLeast","name":"AtLeast","kind":"method","modifiers":[],"parent":"tmux.Version","signatures":[{"params":[{"name":"minimum","type":"Version"}],"returns":"bool"}],"doc":{"summary":"AtLeast reports whether v provides the same or a newer feature level."},"source":{"file":"tmux/version.go","line":242,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Version.AtLeast","product":"core","slug":"tmux-version-atleast"},{"id":"tmux.UnsupportedPolicy","name":"UnsupportedPolicy","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"UnsupportedPolicy selects what a request does when it needs an optional tmux capability the running server does not have.","body":"The default refuses because dropping a flag can change behavior while still\nreturning success.\n\nChoose degradation only when omission is acceptable:\n\nserver, err := tmux.NewServer(tmux.ServerOptions{\n\tUnsupported:    tmux.DegradeUnsupported,\n\tWarningHandler: func(w tmux.Warning) { log.Printf(\"tmux: %s\", w) },\n})\nif err != nil {\n\tlog.Fatal(err)\n}\n\nSet [ServerOptions.WarningHandler] alongside it to observe omissions."},"source":{"file":"tmux/warning.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnsupportedPolicy","product":"core","slug":"tmux-unsupportedpolicy"},{"id":"tmux.FailUnsupported","name":"FailUnsupported","kind":"constant","modifiers":[],"signatures":[],"type":"UnsupportedPolicy","doc":{"summary":"FailUnsupported refuses a request naming a capability the running tmux does not have, with a VersionTooLowError naming the subcommand and the capability. It is the zero value."},"source":{"file":"tmux/warning.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.FailUnsupported","product":"core","slug":"tmux-failunsupported"},{"id":"tmux.DegradeUnsupported","name":"DegradeUnsupported","kind":"constant","modifiers":[],"signatures":[],"type":"UnsupportedPolicy","doc":{"summary":"DegradeUnsupported omits the capability, runs the reduced command, and reports the decision to ServerOptions.WarningHandler as a WarningUnsupportedFeature."},"source":{"file":"tmux/warning.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.DegradeUnsupported","product":"core","slug":"tmux-degradeunsupported"},{"id":"tmux.UnsupportedPolicy.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.UnsupportedPolicy","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer."},"source":{"file":"tmux/warning.go","line":40,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnsupportedPolicy.String","product":"core","slug":"tmux-unsupportedpolicy-string"},{"id":"tmux.WarningKind","name":"WarningKind","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WarningKind identifies one closed class of nonfatal library warning."},"source":{"file":"tmux/warning.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WarningKind","product":"core","slug":"tmux-warningkind"},{"id":"tmux.WarningUnsupportedFeature","name":"WarningUnsupportedFeature","kind":"constant","modifiers":[],"signatures":[],"type":"WarningKind","doc":{"summary":"WarningUnsupportedFeature reports a requested feature omitted because the connected tmux binary is too old."},"source":{"file":"tmux/warning.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WarningUnsupportedFeature","product":"core","slug":"tmux-warningunsupportedfeature"},{"id":"tmux.WarningCommandStderr","name":"WarningCommandStderr","kind":"constant","modifiers":[],"signatures":[],"type":"WarningKind","doc":{"summary":"WarningCommandStderr reports stderr from a completed command whose Python API treats the diagnostic as nonfatal."},"source":{"file":"tmux/warning.go","line":60,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WarningCommandStderr","product":"core","slug":"tmux-warningcommandstderr"},{"id":"tmux.Warning","name":"Warning","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Warning describes one nonfatal compatibility decision delivered to a [WarningHandler]."},"source":{"file":"tmux/warning.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Warning","product":"core","slug":"tmux-warning"},{"id":"tmux.Warning.Kind","name":"Kind","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"WarningKind","doc":{"summary":"Kind classifies the compatibility decision."},"source":{"file":"tmux/warning.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Warning.Kind","product":"core","slug":"tmux-warning-kind"},{"id":"tmux.Warning.Subcommand","name":"Subcommand","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"string","doc":{"summary":"Subcommand names the tmux subcommand affected by the decision."},"source":{"file":"tmux/warning.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Warning.Subcommand","product":"core","slug":"tmux-warning-subcommand"},{"id":"tmux.Warning.Feature","name":"Feature","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"string","doc":{"summary":"Feature names the optional tmux capability involved."},"source":{"file":"tmux/warning.go","line":71,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Warning.Feature","product":"core","slug":"tmux-warning-feature"},{"id":"tmux.Warning.CurrentVersion","name":"CurrentVersion","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"Version","doc":{"summary":"CurrentVersion is the observed tmux version."},"source":{"file":"tmux/warning.go","line":73,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Warning.CurrentVersion","product":"core","slug":"tmux-warning-currentversion"},{"id":"tmux.Warning.RequiredVersion","name":"RequiredVersion","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"Version","doc":{"summary":"RequiredVersion is the minimum tmux version for Feature."},"source":{"file":"tmux/warning.go","line":75,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Warning.RequiredVersion","product":"core","slug":"tmux-warning-requiredversion"},{"id":"tmux.Warning.Message","name":"Message","kind":"attribute","modifiers":[],"parent":"tmux.Warning","signatures":[],"type":"string","doc":{"summary":"Message describes the nonfatal compatibility decision."},"source":{"file":"tmux/warning.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Warning.Message","product":"core","slug":"tmux-warning-message"},{"id":"tmux.WarningHandler","name":"WarningHandler","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WarningHandler receives warnings synchronously on the caller goroutine:","body":"server, err := tmux.NewServer(tmux.ServerOptions{\n\tWarningHandler: func(warning tmux.Warning) {\n\t\tlog.Printf(\"tmux: %s\", warning.Message)\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\n\nOperations may invoke it concurrently; synchronize shared state. Diagnostics\nmay contain caller-supplied arguments and are delivered only to this handler."},"source":{"file":"tmux/warning.go","line":93,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WarningHandler","product":"core","slug":"tmux-warninghandler"},{"id":"tmux.Warning.String","name":"String","kind":"method","modifiers":[],"parent":"tmux.Warning","signatures":[{"params":[],"returns":"string"}],"doc":{"summary":"String implements fmt.Stringer by returning Message."},"source":{"file":"tmux/warning.go","line":96,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Warning.String","product":"core","slug":"tmux-warning-string"},{"id":"tmux.SelectLayoutRequest","name":"SelectLayoutRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SelectLayoutRequest selects one layout operation. Its zero value reapplies the last preset layout. Layout, Spread, Next, and Previous are mutually exclusive and are validated before execution; an empty Layout is omitted rather than passed explicitly. The request contains no retained caller-owned storage and is supported on tmux 3.2a or later."},"source":{"file":"tmux/window_layout.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectLayoutRequest","product":"core","slug":"tmux-selectlayoutrequest"},{"id":"tmux.SelectLayoutRequest.Layout","name":"Layout","kind":"attribute","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[],"type":"string","doc":{"summary":"Layout names a preset or supplies a tmux layout string - either the classic checksum-prefixed grammar every supported version accepts, or the JSON shape tmux 3.8+ also accepts, exactly as #{window_layout} reported it; empty selects the zero-value behavior."},"source":{"file":"tmux/window_layout.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectLayoutRequest.Layout","product":"core","slug":"tmux-selectlayoutrequest-layout"},{"id":"tmux.SelectLayoutRequest.Spread","name":"Spread","kind":"attribute","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[],"type":"bool","doc":{"summary":"Spread distributes pane space evenly."},"source":{"file":"tmux/window_layout.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectLayoutRequest.Spread","product":"core","slug":"tmux-selectlayoutrequest-spread"},{"id":"tmux.SelectLayoutRequest.Next","name":"Next","kind":"attribute","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[],"type":"bool","doc":{"summary":"Next selects the next preset layout."},"source":{"file":"tmux/window_layout.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectLayoutRequest.Next","product":"core","slug":"tmux-selectlayoutrequest-next"},{"id":"tmux.SelectLayoutRequest.Previous","name":"Previous","kind":"attribute","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[],"type":"bool","doc":{"summary":"Previous selects the previous preset layout."},"source":{"file":"tmux/window_layout.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectLayoutRequest.Previous","product":"core","slug":"tmux-selectlayoutrequest-previous"},{"id":"tmux.SelectLayoutRequest.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"tmux.SelectLayoutRequest","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate checks mode exclusivity, NUL bytes, candidate preset names and classic checksummed syntax and JSON envelopes without running tmux. Its zero value is valid. Invalid requests match [ErrInvalidServerCommandRequest]. Names and abbreviations valid on any supported tmux are accepted here; execution checks daemon support. tmux validates JSON contents, geometry and live pane counts when applying it."},"source":{"file":"tmux/window_layout.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SelectLayoutRequest.Validate","product":"core","slug":"tmux-selectlayoutrequest-validate"},{"id":"tmux.Window.SelectLayout","name":"SelectLayout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SelectLayoutRequest"}],"returns":"error"}],"doc":{"summary":"SelectLayout applies one layout operation to the receiver's exact winlink. It changes pane geometry without selecting the window or promising client focus. The materialized receiver is not refreshed, so callers that need current pane geometry must obtain a new snapshot or refresh related models. A transport or context error can be delivery-ambiguous; the void result cannot carry partial state and no rollback is attempted."},"source":{"file":"tmux/window_layout.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SelectLayout","product":"core","slug":"tmux-window-selectlayout"},{"id":"tmux.Window.NextLayout","name":"NextLayout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"NextLayout applies the next preset layout to the receiver's exact winlink. It changes pane geometry without selecting or refreshing the window. A transport or context error can be delivery-ambiguous; the void result cannot carry partial state and no rollback is attempted."},"source":{"file":"tmux/window_layout.go","line":324,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.NextLayout","product":"core","slug":"tmux-window-nextlayout"},{"id":"tmux.Window.PreviousLayout","name":"PreviousLayout","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"PreviousLayout applies the previous preset layout to the receiver's exact winlink. It changes pane geometry without selecting or refreshing the window. A transport or context error can be delivery-ambiguous; the void result cannot carry partial state and no rollback is attempted."},"source":{"file":"tmux/window_layout.go","line":341,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.PreviousLayout","product":"core","slug":"tmux-window-previouslayout"},{"id":"tmux.NewWindowRequest","name":"NewWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NewWindowRequest configures window creation on tmux 3.2a or later. Its zero value uses inherited defaults; placement behavior depends on the receiver. [Session.NewWindow] uses tmux's next free index. [Window.NewWindow] instead targets the receiver's occupied index and normally returns a command error; KillExisting may replace it. [Window.NewWindow] rejects Index. SelectExisting may run name-expansion probes before creation.","body":"Pointer fields are explicit when nonnil. Methods copy them and Environment\nbefore I/O; concurrent mutation during the copy is unsafe."},"source":{"file":"tmux/window_lifecycle.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest","product":"core","slug":"tmux-newwindowrequest"},{"id":"tmux.NewWindowRequest.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"*string","doc":{"summary":"Name is omitted when nil. A nonnil empty string remains an explicit -n operand. The value is copied before tmux is called."},"source":{"file":"tmux/window_lifecycle.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.Name","product":"core","slug":"tmux-newwindowrequest-name"},{"id":"tmux.NewWindowRequest.Attach","name":"Attach","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Attach lets the created or selected winlink become current in the target session; false preserves its current window."},"source":{"file":"tmux/window_lifecycle.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.Attach","product":"core","slug":"tmux-newwindowrequest-attach"},{"id":"tmux.NewWindowRequest.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"*int","doc":{"summary":"Index selects an explicit nonnegative winlink index for Session.NewWindow; nil uses the next free index."},"source":{"file":"tmux/window_lifecycle.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.Index","product":"core","slug":"tmux-newwindowrequest-index"},{"id":"tmux.NewWindowRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Named-user forms such as ~other are rejected; empty inherits tmux's default."},"source":{"file":"tmux/window_lifecycle.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.StartDirectory","product":"core","slug":"tmux-newwindowrequest-startdirectory"},{"id":"tmux.NewWindowRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"string","doc":{"summary":"Command starts the window with this shell command; empty uses tmux's default command."},"source":{"file":"tmux/window_lifecycle.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.Command","product":"core","slug":"tmux-newwindowrequest-command"},{"id":"tmux.NewWindowRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order. The map is not retained; nil and an empty map both add no entries."},"source":{"file":"tmux/window_lifecycle.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.Environment","product":"core","slug":"tmux-newwindowrequest-environment"},{"id":"tmux.NewWindowRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"NewWindowDirection","doc":{"summary":"Direction places the new winlink relative to the target. Its zero value uses tmux's next free index with Session.NewWindow when Index is nil, but keeps Window.NewWindow on the receiver's occupied target. Use NewWindowDirectionAfter or NewWindowDirectionBefore for non-destructive relative creation through Window.NewWindow."},"source":{"file":"tmux/window_lifecycle.go","line":44,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.Direction","product":"core","slug":"tmux-newwindowrequest-direction"},{"id":"tmux.NewWindowRequest.KillExisting","name":"KillExisting","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KillExisting asks tmux to destroy a window occupying the target index."},"source":{"file":"tmux/window_lifecycle.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.KillExisting","product":"core","slug":"tmux-newwindowrequest-killexisting"},{"id":"tmux.NewWindowRequest.SelectExisting","name":"SelectExisting","kind":"attribute","modifiers":[],"parent":"tmux.NewWindowRequest","signatures":[],"type":"bool","doc":{"summary":"SelectExisting asks tmux to select an existing expanded-name match instead of creating another window. It requires Name."},"source":{"file":"tmux/window_lifecycle.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowRequest.SelectExisting","product":"core","slug":"tmux-newwindowrequest-selectexisting"},{"id":"tmux.NewWindowDirection","name":"NewWindowDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"NewWindowDirection selects placement relative to the target winlink on tmux 3.2a or later. Its zero value lets [Session.NewWindow] with nil Index use the next free index, while [Window.NewWindow] keeps the receiver's exact occupied target."},"source":{"file":"tmux/window_lifecycle.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowDirection","product":"core","slug":"tmux-newwindowdirection"},{"id":"tmux.NewWindowDirectionDefault","name":"NewWindowDirectionDefault","kind":"constant","modifiers":[],"signatures":[],"type":"NewWindowDirection","doc":{"summary":"NewWindowDirectionDefault uses the next free index with Session.NewWindow when Index is nil; Window.NewWindow instead keeps the receiver's exact occupied target."},"source":{"file":"tmux/window_lifecycle.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowDirectionDefault","product":"core","slug":"tmux-newwindowdirectiondefault"},{"id":"tmux.NewWindowDirectionAfter","name":"NewWindowDirectionAfter","kind":"constant","modifiers":[],"signatures":[],"type":"NewWindowDirection","doc":{"summary":"NewWindowDirectionAfter places the new winlink after the target."},"source":{"file":"tmux/window_lifecycle.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowDirectionAfter","product":"core","slug":"tmux-newwindowdirectionafter"},{"id":"tmux.NewWindowDirectionBefore","name":"NewWindowDirectionBefore","kind":"constant","modifiers":[],"signatures":[],"type":"NewWindowDirection","doc":{"summary":"NewWindowDirectionBefore places the new winlink before the target."},"source":{"file":"tmux/window_lifecycle.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.NewWindowDirectionBefore","product":"core","slug":"tmux-newwindowdirectionbefore"},{"id":"tmux.Session.NewWindow","name":"NewWindow","kind":"method","modifiers":[],"parent":"tmux.Session","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"NewWindow creates a winlink in the receiver session. Attach selects it as that session's current window; it is not a guarantee about clients attached to other sessions. The returned [Window] is freshly materialized in the receiver's exact session context, including when its stable [WindowID] is linked elsewhere.","body":"SelectExisting no-output recovery is available only when Index is nil. It\nexpands Name with tmux's version-specific rules and requires exactly one\nmatching window name in the receiver session. An explicit Index has no such\nrecovery. If tmux reports a WindowID before a transport or refresh failure,\nthe partial result contains that ID and the receiver SessionID with Index -1.\nOther failures return zero; creation is not rolled back."},"source":{"file":"tmux/window_lifecycle.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Session.NewWindow","product":"core","slug":"tmux-session-newwindow"},{"id":"tmux.Window.NewWindow","name":"NewWindow","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"NewWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"NewWindow creates a window relative to the receiver's exact winlink. Set Direction to [NewWindowDirectionAfter] or [NewWindowDirectionBefore] for non-destructive relative creation. With the zero Direction, tmux targets the receiver's occupied index and normally returns a command error; KillExisting can destroy and replace that target. Attach changes the current window only in that target session. Index is rejected before execution because the receiver already supplies the target position. On tmux 3.8 and later, SelectExisting's -S also matches the receiver's own exact target (extended there to match -t as well as a window's name), so it always selects the receiver itself and prints nothing; the identity is already known without a probe. Earlier tmux only matched -S by name here, and always printed a created WindowID because the exact-target form never carries a bare name to match against.","body":"If tmux reports an ID before a transport or refresh failure, the partial result\ncontains it and the receiver SessionID with Index -1. Other failures return\nzero; creation is not rolled back."},"source":{"file":"tmux/window_lifecycle.go","line":108,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.NewWindow","product":"core","slug":"tmux-window-newwindow"},{"id":"tmux.Window.Rename","name":"Rename","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"name","type":"string"}],"returns":"(Window, error)"}],"doc":{"summary":"Rename changes the stable window through the receiver's exact winlink and returns a canonical freshly materialized [Window]. The returned winlink may therefore use another session when the WindowID is linked. If the command succeeds but refresh fails, Rename returns the receiver with that error. A transport or context error can be delivery-ambiguous; no rollback is attempted."},"source":{"file":"tmux/window_lifecycle.go","line":348,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Rename","product":"core","slug":"tmux-window-rename"},{"id":"tmux.Window.Select","name":"Select","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"(Window, error)"}],"doc":{"summary":"Select makes the receiver's exact winlink current in its session. It does not promise focus for clients attached to other sessions. Select returns a canonical freshly materialized [Window], which may use another linked session for the same WindowID. If the command succeeds but refresh fails, it returns the receiver with that error. A transport or context error can be delivery-ambiguous; no rollback is attempted."},"source":{"file":"tmux/window_lifecycle.go","line":377,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Select","product":"core","slug":"tmux-window-select"},{"id":"tmux.LinkWindowRequest","name":"LinkWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"LinkWindowRequest configures linking a window into another session on tmux 3.2a or later. Its zero value is invalid because TargetSession is required. Nil TargetIndex asks tmux for a destination index; a nonnil value is explicit and must be nonnegative. After and Before are mutually exclusive and are rejected before execution. TargetIndex is read during the call and is not retained; callers must not mutate it concurrently."},"source":{"file":"tmux/window_link_move.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LinkWindowRequest","product":"core","slug":"tmux-linkwindowrequest"},{"id":"tmux.LinkWindowRequest.TargetSession","name":"TargetSession","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"SessionID","doc":{"summary":"TargetSession identifies the destination session in the receiver's tmux server."},"source":{"file":"tmux/window_link_move.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LinkWindowRequest.TargetSession","product":"core","slug":"tmux-linkwindowrequest-targetsession"},{"id":"tmux.LinkWindowRequest.TargetIndex","name":"TargetIndex","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"*int","doc":{"summary":"TargetIndex selects a destination winlink index; nil lets tmux choose."},"source":{"file":"tmux/window_link_move.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LinkWindowRequest.TargetIndex","product":"core","slug":"tmux-linkwindowrequest-targetindex"},{"id":"tmux.LinkWindowRequest.KillExisting","name":"KillExisting","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KillExisting destroys a window already occupying the destination."},"source":{"file":"tmux/window_link_move.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LinkWindowRequest.KillExisting","product":"core","slug":"tmux-linkwindowrequest-killexisting"},{"id":"tmux.LinkWindowRequest.After","name":"After","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"After inserts the new winlink after the destination target."},"source":{"file":"tmux/window_link_move.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LinkWindowRequest.After","product":"core","slug":"tmux-linkwindowrequest-after"},{"id":"tmux.LinkWindowRequest.Before","name":"Before","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Before inserts the new winlink before the destination target."},"source":{"file":"tmux/window_link_move.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LinkWindowRequest.Before","product":"core","slug":"tmux-linkwindowrequest-before"},{"id":"tmux.LinkWindowRequest.Detach","name":"Detach","kind":"attribute","modifiers":[],"parent":"tmux.LinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Detach leaves the target session's current window unchanged."},"source":{"file":"tmux/window_link_move.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LinkWindowRequest.Detach","product":"core","slug":"tmux-linkwindowrequest-detach"},{"id":"tmux.UnlinkWindowRequest","name":"UnlinkWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"UnlinkWindowRequest configures unlinking one exact winlink on tmux 3.2a or later. Its zero value removes the link only when the stable window has another link. The request contains no retained caller-owned storage and has no invalid field combinations."},"source":{"file":"tmux/window_link_move.go","line":34,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnlinkWindowRequest","product":"core","slug":"tmux-unlinkwindowrequest"},{"id":"tmux.UnlinkWindowRequest.KillIfLast","name":"KillIfLast","kind":"attribute","modifiers":[],"parent":"tmux.UnlinkWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KillIfLast permits unlinking and destroying a stable window with no other links."},"source":{"file":"tmux/window_link_move.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.UnlinkWindowRequest.KillIfLast","product":"core","slug":"tmux-unlinkwindowrequest-killiflast"},{"id":"tmux.MoveWindowRequest","name":"MoveWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"MoveWindowRequest configures moving one exact winlink on tmux 3.2a or later. Its zero value moves the receiver within its current session to a tmux-chosen index and lets the moved winlink become current. Nil TargetIndex asks tmux for that index; a nonnil value is explicit and must be nonnegative. After and Before are mutually exclusive. Renumber is a standalone mode mutually exclusive with TargetIndex, After, Before, NoSelect, and KillTarget. Invalid combinations are rejected before execution. TargetIndex is read during the call and is not retained; callers must not mutate it concurrently."},"source":{"file":"tmux/window_link_move.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MoveWindowRequest","product":"core","slug":"tmux-movewindowrequest"},{"id":"tmux.MoveWindowRequest.TargetSession","name":"TargetSession","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"SessionID","doc":{"summary":"TargetSession identifies the destination session; zero uses the receiver session."},"source":{"file":"tmux/window_link_move.go","line":51,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MoveWindowRequest.TargetSession","product":"core","slug":"tmux-movewindowrequest-targetsession"},{"id":"tmux.MoveWindowRequest.TargetIndex","name":"TargetIndex","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"*int","doc":{"summary":"TargetIndex selects a destination winlink index; nil lets tmux choose."},"source":{"file":"tmux/window_link_move.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MoveWindowRequest.TargetIndex","product":"core","slug":"tmux-movewindowrequest-targetindex"},{"id":"tmux.MoveWindowRequest.After","name":"After","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"After inserts the moved winlink after the destination target."},"source":{"file":"tmux/window_link_move.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MoveWindowRequest.After","product":"core","slug":"tmux-movewindowrequest-after"},{"id":"tmux.MoveWindowRequest.Before","name":"Before","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Before inserts the moved winlink before the destination target."},"source":{"file":"tmux/window_link_move.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MoveWindowRequest.Before","product":"core","slug":"tmux-movewindowrequest-before"},{"id":"tmux.MoveWindowRequest.NoSelect","name":"NoSelect","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"NoSelect leaves the destination session's current window unchanged."},"source":{"file":"tmux/window_link_move.go","line":59,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MoveWindowRequest.NoSelect","product":"core","slug":"tmux-movewindowrequest-noselect"},{"id":"tmux.MoveWindowRequest.KillTarget","name":"KillTarget","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KillTarget destroys a window already occupying the destination."},"source":{"file":"tmux/window_link_move.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MoveWindowRequest.KillTarget","product":"core","slug":"tmux-movewindowrequest-killtarget"},{"id":"tmux.MoveWindowRequest.Renumber","name":"Renumber","kind":"attribute","modifiers":[],"parent":"tmux.MoveWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Renumber renumbers the target session according to its base-index option instead of moving the receiver to a new destination."},"source":{"file":"tmux/window_link_move.go","line":64,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.MoveWindowRequest.Renumber","product":"core","slug":"tmux-movewindowrequest-renumber"},{"id":"tmux.Window.Link","name":"Link","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"LinkWindowRequest"}],"returns":"error"}],"doc":{"summary":"Link adds the stable window to TargetSession as another winlink, targeting the source through the receiver's exact session. Unless Detach is set, tmux makes the new link current in the target session; this is not a global client-focus guarantee. Link does not refresh or mutate the materialized source [Window]. A transport or context error can be delivery-ambiguous; the void result cannot carry the new winlink identity and no rollback is attempted."},"source":{"file":"tmux/window_link_move.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Link","product":"core","slug":"tmux-window-link"},{"id":"tmux.Window.Unlink","name":"Unlink","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"UnlinkWindowRequest"}],"returns":"error"}],"doc":{"summary":"Unlink removes the receiver's exact session winlink without refreshing the materialized receiver. Without KillIfLast, tmux rejects removal of a stable window's only link; with it, that window is destroyed. A transport or context error can be delivery-ambiguous; the void result cannot carry partial identity and no rollback is attempted."},"source":{"file":"tmux/window_link_move.go","line":149,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Unlink","product":"core","slug":"tmux-window-unlink"},{"id":"tmux.Window.Move","name":"Move","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"MoveWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"Move removes the receiver's exact winlink and places it in TargetSession, or renumbers the selected session when Renumber is set. Unless NoSelect is set, tmux makes the moved winlink current in the destination session; this is not a global client-focus guarantee. The stable WindowID does not by itself identify either linked view.","body":"Move returns a canonical freshly materialized [Window], which may use a\ndifferent linked session than the destination. If the command succeeds but\nrefresh fails, it returns the receiver with that error. Earlier failures\nreturn zero; transport errors are delivery-ambiguous."},"source":{"file":"tmux/window_link_move.go","line":174,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Move","product":"core","slug":"tmux-window-move"},{"id":"tmux.SwapWindowRequest","name":"SwapWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SwapWindowRequest configures swapping the receiver with one exact winlink on tmux 3.2a or later. Its zero value is invalid because Target must be a complete Window handle. The endpoints must be proven to share a daemon through connection state or the same nonempty SocketPath; matching socket names alone are insufficient. Validation completes before execution."},"source":{"file":"tmux/window_pane_swap.go","line":10,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapWindowRequest","product":"core","slug":"tmux-swapwindowrequest"},{"id":"tmux.SwapWindowRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.SwapWindowRequest","signatures":[],"type":"Window","doc":{"summary":"Target is the exact other winlink to swap with the receiver."},"source":{"file":"tmux/window_pane_swap.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapWindowRequest.Target","product":"core","slug":"tmux-swapwindowrequest-target"},{"id":"tmux.SwapWindowRequest.Detach","name":"Detach","kind":"attribute","modifiers":[],"parent":"tmux.SwapWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Detach leaves the affected sessions' current-window selection unchanged."},"source":{"file":"tmux/window_pane_swap.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapWindowRequest.Detach","product":"core","slug":"tmux-swapwindowrequest-detach"},{"id":"tmux.WindowSwapResult","name":"WindowSwapResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowSwapResult contains both original stable window identities in their post-swap exact winlink views. Its zero value contains no usable endpoints."},"source":{"file":"tmux/window_pane_swap.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSwapResult","product":"core","slug":"tmux-windowswapresult"},{"id":"tmux.WindowSwapResult.Window","name":"Window","kind":"attribute","modifiers":[],"parent":"tmux.WindowSwapResult","signatures":[],"type":"Window","doc":{"summary":"Window is the receiver's original WindowID at its post-swap exact winlink."},"source":{"file":"tmux/window_pane_swap.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSwapResult.Window","product":"core","slug":"tmux-windowswapresult-window"},{"id":"tmux.WindowSwapResult.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.WindowSwapResult","signatures":[],"type":"Window","doc":{"summary":"Target is the target's original WindowID at its post-swap exact winlink."},"source":{"file":"tmux/window_pane_swap.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSwapResult.Target","product":"core","slug":"tmux-windowswapresult-target"},{"id":"tmux.SwapPaneDirection","name":"SwapPaneDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SwapPaneDirection selects an adjacent pane for swap-pane on tmux 3.2a or later. Its zero value selects no adjacent pane."},"source":{"file":"tmux/window_pane_swap.go","line":28,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneDirection","product":"core","slug":"tmux-swappanedirection"},{"id":"tmux.SwapPaneDirectionNone","name":"SwapPaneDirectionNone","kind":"constant","modifiers":[],"signatures":[],"type":"SwapPaneDirection","doc":{"summary":"SwapPaneDirectionNone selects no adjacent pane."},"source":{"file":"tmux/window_pane_swap.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneDirectionNone","product":"core","slug":"tmux-swappanedirectionnone"},{"id":"tmux.SwapPaneDirectionUp","name":"SwapPaneDirectionUp","kind":"constant","modifiers":[],"signatures":[],"type":"SwapPaneDirection","doc":{"summary":"SwapPaneDirectionUp swaps with the previous pane in index order."},"source":{"file":"tmux/window_pane_swap.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneDirectionUp","product":"core","slug":"tmux-swappanedirectionup"},{"id":"tmux.SwapPaneDirectionDown","name":"SwapPaneDirectionDown","kind":"constant","modifiers":[],"signatures":[],"type":"SwapPaneDirection","doc":{"summary":"SwapPaneDirectionDown swaps with the next pane in index order."},"source":{"file":"tmux/window_pane_swap.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneDirectionDown","product":"core","slug":"tmux-swappanedirectiondown"},{"id":"tmux.SwapPaneRequest","name":"SwapPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"SwapPaneRequest configures swapping with an exact or adjacent pane on tmux 3.2a or later. Its zero value is invalid: exactly one complete Target or Direction is required. An explicit Target must differ from the receiver and must be proven to share a daemon through connection state or the same nonempty SocketPath; matching socket names alone are insufficient. Invalid choices are rejected before execution."},"source":{"file":"tmux/window_pane_swap.go","line":46,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneRequest","product":"core","slug":"tmux-swappanerequest"},{"id":"tmux.SwapPaneRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.SwapPaneRequest","signatures":[],"type":"Pane","doc":{"summary":"Target selects an exact other pane; a zero Pane omits it."},"source":{"file":"tmux/window_pane_swap.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneRequest.Target","product":"core","slug":"tmux-swappanerequest-target"},{"id":"tmux.SwapPaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.SwapPaneRequest","signatures":[],"type":"SwapPaneDirection","doc":{"summary":"Direction selects an adjacent pane; zero omits it."},"source":{"file":"tmux/window_pane_swap.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneRequest.Direction","product":"core","slug":"tmux-swappanerequest-direction"},{"id":"tmux.SwapPaneRequest.Detach","name":"Detach","kind":"attribute","modifiers":[],"parent":"tmux.SwapPaneRequest","signatures":[],"type":"bool","doc":{"summary":"Detach leaves the active-pane selection unchanged."},"source":{"file":"tmux/window_pane_swap.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneRequest.Detach","product":"core","slug":"tmux-swappanerequest-detach"},{"id":"tmux.SwapPaneRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.SwapPaneRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the affected window's zoomed state."},"source":{"file":"tmux/window_pane_swap.go","line":54,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.SwapPaneRequest.KeepZoom","product":"core","slug":"tmux-swappanerequest-keepzoom"},{"id":"tmux.PaneSwapResult","name":"PaneSwapResult","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneSwapResult contains original stable pane identities in their post-swap exact linked-pane views. Its zero value contains no usable endpoints. Target is zero for a directional swap because tmux does not report the adjacent pane identity."},"source":{"file":"tmux/window_pane_swap.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSwapResult","product":"core","slug":"tmux-paneswapresult"},{"id":"tmux.PaneSwapResult.Pane","name":"Pane","kind":"attribute","modifiers":[],"parent":"tmux.PaneSwapResult","signatures":[],"type":"Pane","doc":{"summary":"Pane is the receiver's original PaneID at its post-swap exact view."},"source":{"file":"tmux/window_pane_swap.go","line":63,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSwapResult.Pane","product":"core","slug":"tmux-paneswapresult-pane"},{"id":"tmux.PaneSwapResult.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.PaneSwapResult","signatures":[],"type":"Pane","doc":{"summary":"Target is the explicit target's original PaneID at its post-swap exact view, or zero after a directional swap."},"source":{"file":"tmux/window_pane_swap.go","line":66,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSwapResult.Target","product":"core","slug":"tmux-paneswapresult-target"},{"id":"tmux.Window.Swap","name":"Swap","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SwapWindowRequest"}],"returns":"(WindowSwapResult, error)"}],"doc":{"summary":"Swap exchanges the receiver and Target exact winlinks. Their stable WindowIDs move to the opposite session-and-index views; a WindowID alone does not identify either endpoint. Unless Detach is set, tmux may change the affected sessions' current-window selection; this is not a global client-focus guarantee.","body":"Swap returns both freshly materialized exact endpoint views. If exact\nrefresh fails after the command, it returns a predicted [WindowSwapResult]\ncarrying both stable IDs and post-swap session/index contexts with the\nerror. Earlier failures return zero; transport errors are delivery-ambiguous."},"source":{"file":"tmux/window_pane_swap.go","line":79,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Swap","product":"core","slug":"tmux-window-swap"},{"id":"tmux.Pane.Swap","name":"Swap","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"SwapPaneRequest"}],"returns":"(PaneSwapResult, error)"}],"doc":{"summary":"Swap exchanges the receiver with one exact or adjacent pane. Explicit targets use exact linked-pane views; PaneID alone does not distinguish linked views. Unless Detach is set, tmux may change active-pane selection; this is not a global client-focus guarantee. A directional swap cannot identify the adjacent target because tmux does not report it, so the returned [PaneSwapResult].Target is zero.","body":"An explicit swap returns freshly materialized exact views for both original\nPaneIDs. If exact refresh fails after the command, Swap returns a predicted\nresult carrying every known identity with the error. Earlier failures return\nzero; transport errors are delivery-ambiguous."},"source":{"file":"tmux/window_pane_swap.go","line":133,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Swap","product":"core","slug":"tmux-pane-swap"},{"id":"tmux.PaneSelectDirection","name":"PaneSelectDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneSelectDirection selects a pane relative to the command target on tmux 3.2a or later. Its zero value selects no relative direction."},"source":{"file":"tmux/window_pane_topology.go","line":7,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectDirection","product":"core","slug":"tmux-paneselectdirection"},{"id":"tmux.PaneSelectDirectionNone","name":"PaneSelectDirectionNone","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionNone selects no relative pane."},"source":{"file":"tmux/window_pane_topology.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectDirectionNone","product":"core","slug":"tmux-paneselectdirectionnone"},{"id":"tmux.PaneSelectDirectionUp","name":"PaneSelectDirectionUp","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionUp selects the pane above the target."},"source":{"file":"tmux/window_pane_topology.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectDirectionUp","product":"core","slug":"tmux-paneselectdirectionup"},{"id":"tmux.PaneSelectDirectionDown","name":"PaneSelectDirectionDown","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionDown selects the pane below the target."},"source":{"file":"tmux/window_pane_topology.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectDirectionDown","product":"core","slug":"tmux-paneselectdirectiondown"},{"id":"tmux.PaneSelectDirectionLeft","name":"PaneSelectDirectionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionLeft selects the pane to the left of the target."},"source":{"file":"tmux/window_pane_topology.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectDirectionLeft","product":"core","slug":"tmux-paneselectdirectionleft"},{"id":"tmux.PaneSelectDirectionRight","name":"PaneSelectDirectionRight","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionRight selects the pane to the right of the target."},"source":{"file":"tmux/window_pane_topology.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectDirectionRight","product":"core","slug":"tmux-paneselectdirectionright"},{"id":"tmux.PaneSelectDirectionLast","name":"PaneSelectDirectionLast","kind":"constant","modifiers":[],"signatures":[],"type":"PaneSelectDirection","doc":{"summary":"PaneSelectDirectionLast selects the previously active pane."},"source":{"file":"tmux/window_pane_topology.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectDirectionLast","product":"core","slug":"tmux-paneselectdirectionlast"},{"id":"tmux.PaneMarkMode","name":"PaneMarkMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneMarkMode changes tmux's server-wide marked pane on tmux 3.2a or later. Its zero value leaves the mark unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneMarkMode","product":"core","slug":"tmux-panemarkmode"},{"id":"tmux.PaneMarkUnchanged","name":"PaneMarkUnchanged","kind":"constant","modifiers":[],"signatures":[],"type":"PaneMarkMode","doc":{"summary":"PaneMarkUnchanged leaves the server-wide marked pane unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneMarkUnchanged","product":"core","slug":"tmux-panemarkunchanged"},{"id":"tmux.PaneMarkSet","name":"PaneMarkSet","kind":"constant","modifiers":[],"signatures":[],"type":"PaneMarkMode","doc":{"summary":"PaneMarkSet makes the target the server-wide marked pane without selecting it."},"source":{"file":"tmux/window_pane_topology.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneMarkSet","product":"core","slug":"tmux-panemarkset"},{"id":"tmux.PaneMarkClear","name":"PaneMarkClear","kind":"constant","modifiers":[],"signatures":[],"type":"PaneMarkMode","doc":{"summary":"PaneMarkClear clears the server-wide marked pane without selecting the target."},"source":{"file":"tmux/window_pane_topology.go","line":38,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneMarkClear","product":"core","slug":"tmux-panemarkclear"},{"id":"tmux.PaneInputMode","name":"PaneInputMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneInputMode changes whether a pane accepts input on tmux 3.2a or later. Its zero value leaves input state unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneInputMode","product":"core","slug":"tmux-paneinputmode"},{"id":"tmux.PaneInputUnchanged","name":"PaneInputUnchanged","kind":"constant","modifiers":[],"signatures":[],"type":"PaneInputMode","doc":{"summary":"PaneInputUnchanged leaves the target pane's input state unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneInputUnchanged","product":"core","slug":"tmux-paneinputunchanged"},{"id":"tmux.PaneInputDisable","name":"PaneInputDisable","kind":"constant","modifiers":[],"signatures":[],"type":"PaneInputMode","doc":{"summary":"PaneInputDisable disables input without selecting the target pane."},"source":{"file":"tmux/window_pane_topology.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneInputDisable","product":"core","slug":"tmux-paneinputdisable"},{"id":"tmux.PaneInputEnable","name":"PaneInputEnable","kind":"constant","modifiers":[],"signatures":[],"type":"PaneInputMode","doc":{"summary":"PaneInputEnable enables input without selecting the target pane."},"source":{"file":"tmux/window_pane_topology.go","line":52,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneInputEnable","product":"core","slug":"tmux-paneinputenable"},{"id":"tmux.WindowSelectPaneRequest","name":"WindowSelectPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowSelectPaneRequest selects either one exact pane or one relative pane. Its zero value is invalid: exactly one of Target and Direction is required. Target must be a complete pane handle in the receiver's exact winlink and must be proven to share a daemon through connection state or the same nonempty SocketPath; matching socket names alone are insufficient. Invalid values are rejected before execution."},"source":{"file":"tmux/window_pane_topology.go","line":61,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSelectPaneRequest","product":"core","slug":"tmux-windowselectpanerequest"},{"id":"tmux.WindowSelectPaneRequest.Target","name":"Target","kind":"attribute","modifiers":[],"parent":"tmux.WindowSelectPaneRequest","signatures":[],"type":"Pane","doc":{"summary":"Target selects one exact pane in the receiver winlink; a zero Pane omits this choice."},"source":{"file":"tmux/window_pane_topology.go","line":64,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSelectPaneRequest.Target","product":"core","slug":"tmux-windowselectpanerequest-target"},{"id":"tmux.WindowSelectPaneRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.WindowSelectPaneRequest","signatures":[],"type":"PaneSelectDirection","doc":{"summary":"Direction selects a pane relative to the receiver window's active pane; zero omits this choice."},"source":{"file":"tmux/window_pane_topology.go","line":67,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSelectPaneRequest.Direction","product":"core","slug":"tmux-windowselectpanerequest-direction"},{"id":"tmux.WindowSelectPaneRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.WindowSelectPaneRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the window's zoomed state."},"source":{"file":"tmux/window_pane_topology.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowSelectPaneRequest.KeepZoom","product":"core","slug":"tmux-windowselectpanerequest-keepzoom"},{"id":"tmux.PaneSelectRequest","name":"PaneSelectRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PaneSelectRequest configures select-pane for one exact receiver. Closed enums prevent conflicting direction, mark, and input flags. Its zero value selects the receiver. Mark rejects every other option. Input rejects Direction and KeepZoom because changing input does not select a pane. These combinations and enum ranges are validated before execution."},"source":{"file":"tmux/window_pane_topology.go","line":77,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectRequest","product":"core","slug":"tmux-paneselectrequest"},{"id":"tmux.PaneSelectRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.PaneSelectRequest","signatures":[],"type":"PaneSelectDirection","doc":{"summary":"Direction selects a pane relative to the receiver; zero selects the receiver unless Mark or Input is set."},"source":{"file":"tmux/window_pane_topology.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectRequest.Direction","product":"core","slug":"tmux-paneselectrequest-direction"},{"id":"tmux.PaneSelectRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.PaneSelectRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the window's zoomed state while selecting."},"source":{"file":"tmux/window_pane_topology.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectRequest.KeepZoom","product":"core","slug":"tmux-paneselectrequest-keepzoom"},{"id":"tmux.PaneSelectRequest.Mark","name":"Mark","kind":"attribute","modifiers":[],"parent":"tmux.PaneSelectRequest","signatures":[],"type":"PaneMarkMode","doc":{"summary":"Mark changes the server-wide marked pane without selecting; zero leaves it unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":85,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectRequest.Mark","product":"core","slug":"tmux-paneselectrequest-mark"},{"id":"tmux.PaneSelectRequest.Input","name":"Input","kind":"attribute","modifiers":[],"parent":"tmux.PaneSelectRequest","signatures":[],"type":"PaneInputMode","doc":{"summary":"Input changes whether the receiver accepts input without selecting; zero leaves input state unchanged."},"source":{"file":"tmux/window_pane_topology.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.PaneSelectRequest.Input","product":"core","slug":"tmux-paneselectrequest-input"},{"id":"tmux.LastPaneRequest","name":"LastPaneRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"LastPaneRequest configures last-pane on tmux 3.2a or later. Its zero value selects the previously active pane. Input and KeepZoom are mutually exclusive and are validated before execution; an Input mode changes the previous pane's input state without selecting it."},"source":{"file":"tmux/window_pane_topology.go","line":95,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LastPaneRequest","product":"core","slug":"tmux-lastpanerequest"},{"id":"tmux.LastPaneRequest.Input","name":"Input","kind":"attribute","modifiers":[],"parent":"tmux.LastPaneRequest","signatures":[],"type":"PaneInputMode","doc":{"summary":"Input changes the previous pane's input state; zero performs selection."},"source":{"file":"tmux/window_pane_topology.go","line":97,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LastPaneRequest.Input","product":"core","slug":"tmux-lastpanerequest-input"},{"id":"tmux.LastPaneRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.LastPaneRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the window's zoomed state during selection."},"source":{"file":"tmux/window_pane_topology.go","line":99,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.LastPaneRequest.KeepZoom","product":"core","slug":"tmux-lastpanerequest-keepzoom"},{"id":"tmux.RotateWindowDirection","name":"RotateWindowDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RotateWindowDirection selects rotate-window's direction on tmux 3.2a or later. Its zero value uses tmux's default rotation."},"source":{"file":"tmux/window_pane_topology.go","line":104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RotateWindowDirection","product":"core","slug":"tmux-rotatewindowdirection"},{"id":"tmux.RotateWindowDefault","name":"RotateWindowDefault","kind":"constant","modifiers":[],"signatures":[],"type":"RotateWindowDirection","doc":{"summary":"RotateWindowDefault uses tmux's default rotation."},"source":{"file":"tmux/window_pane_topology.go","line":109,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RotateWindowDefault","product":"core","slug":"tmux-rotatewindowdefault"},{"id":"tmux.RotateWindowUp","name":"RotateWindowUp","kind":"constant","modifiers":[],"signatures":[],"type":"RotateWindowDirection","doc":{"summary":"RotateWindowUp rotates pane positions toward lower indexes."},"source":{"file":"tmux/window_pane_topology.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RotateWindowUp","product":"core","slug":"tmux-rotatewindowup"},{"id":"tmux.RotateWindowDown","name":"RotateWindowDown","kind":"constant","modifiers":[],"signatures":[],"type":"RotateWindowDirection","doc":{"summary":"RotateWindowDown rotates pane positions toward higher indexes."},"source":{"file":"tmux/window_pane_topology.go","line":113,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RotateWindowDown","product":"core","slug":"tmux-rotatewindowdown"},{"id":"tmux.RotateWindowRequest","name":"RotateWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RotateWindowRequest configures rotate-window. Its zero value uses tmux's default rotation; enum validation happens before execution."},"source":{"file":"tmux/window_pane_topology.go","line":118,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RotateWindowRequest","product":"core","slug":"tmux-rotatewindowrequest"},{"id":"tmux.RotateWindowRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.RotateWindowRequest","signatures":[],"type":"RotateWindowDirection","doc":{"summary":"Direction selects the rotation direction; zero uses tmux's default."},"source":{"file":"tmux/window_pane_topology.go","line":120,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RotateWindowRequest.Direction","product":"core","slug":"tmux-rotatewindowrequest-direction"},{"id":"tmux.RotateWindowRequest.KeepZoom","name":"KeepZoom","kind":"attribute","modifiers":[],"parent":"tmux.RotateWindowRequest","signatures":[],"type":"bool","doc":{"summary":"KeepZoom preserves the window's zoomed state."},"source":{"file":"tmux/window_pane_topology.go","line":122,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RotateWindowRequest.KeepZoom","product":"core","slug":"tmux-rotatewindowrequest-keepzoom"},{"id":"tmux.Window.SelectPane","name":"SelectPane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"WindowSelectPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"SelectPane makes an exact or relative pane active in the receiver's exact winlink without selecting the window in its session. Target must belong to that same SessionID and WindowID; a PaneID alone does not identify a linked view. The returned [Pane] is the freshly materialized active pane in the receiver context, not a canonical ID-only view.","body":"Command or refresh failures return zero because active-pane selection has no\nreliable partial identity. Transport errors are delivery-ambiguous."},"source":{"file":"tmux/window_pane_topology.go","line":133,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.SelectPane","product":"core","slug":"tmux-window-selectpane"},{"id":"tmux.Pane.Select","name":"Select","kind":"method","modifiers":[],"parent":"tmux.Pane","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"PaneSelectRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"Select applies select-pane to the receiver's exact linked-pane view. Direction makes an adjacent pane active, but the returned [Pane] is a fresh exact refresh of the receiver rather than the newly active pane. With no Direction, Mark, or Input, the receiver becomes active. Mark changes the server-wide marked pane without selection; Input changes the receiver's input state without selection. None of these modes selects the window in its session or promises client focus.","body":"A refresh failure returns the receiver with the error; earlier failures return zero."},"source":{"file":"tmux/window_pane_topology.go","line":186,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Pane.Select","product":"core","slug":"tmux-pane-select"},{"id":"tmux.Window.LastPane","name":"LastPane","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"LastPaneRequest"}],"returns":"(Pane, error)"}],"doc":{"summary":"LastPane targets the receiver's exact winlink. Its zero request makes the previously active pane active without selecting the window in its session. With an Input mode, tmux changes the previous pane's input state without selecting it; the returned [Pane] is still the freshly materialized active pane in the receiver context.","body":"Command or refresh failures return zero because the active view needs refresh."},"source":{"file":"tmux/window_pane_topology.go","line":213,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.LastPane","product":"core","slug":"tmux-window-lastpane"},{"id":"tmux.Window.Rotate","name":"Rotate","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RotateWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"Rotate rotates pane positions in the receiver's exact winlink without selecting the window or promising client focus. It returns a freshly materialized exact [Window] preserving the receiver SessionID, rather than a canonical ID-only view. If the command succeeds but refresh fails, Rotate returns the receiver with that error; earlier failures return zero."},"source":{"file":"tmux/window_pane_topology.go","line":247,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Rotate","product":"core","slug":"tmux-window-rotate"},{"id":"tmux.WindowResizeDirection","name":"WindowResizeDirection","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"WindowResizeDirection selects one directional resize operation on tmux 3.2a or later. Its zero value selects no directional adjustment."},"source":{"file":"tmux/window_resize.go","line":10,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowResizeDirection","product":"core","slug":"tmux-windowresizedirection"},{"id":"tmux.WindowResizeDirectionNone","name":"WindowResizeDirectionNone","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionNone selects no directional adjustment."},"source":{"file":"tmux/window_resize.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowResizeDirectionNone","product":"core","slug":"tmux-windowresizedirectionnone"},{"id":"tmux.WindowResizeDirectionUp","name":"WindowResizeDirectionUp","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionUp adjusts the window upward."},"source":{"file":"tmux/window_resize.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowResizeDirectionUp","product":"core","slug":"tmux-windowresizedirectionup"},{"id":"tmux.WindowResizeDirectionDown","name":"WindowResizeDirectionDown","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionDown adjusts the window downward."},"source":{"file":"tmux/window_resize.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowResizeDirectionDown","product":"core","slug":"tmux-windowresizedirectiondown"},{"id":"tmux.WindowResizeDirectionLeft","name":"WindowResizeDirectionLeft","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionLeft adjusts the window leftward."},"source":{"file":"tmux/window_resize.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowResizeDirectionLeft","product":"core","slug":"tmux-windowresizedirectionleft"},{"id":"tmux.WindowResizeDirectionRight","name":"WindowResizeDirectionRight","kind":"constant","modifiers":[],"signatures":[],"type":"WindowResizeDirection","doc":{"summary":"WindowResizeDirectionRight adjusts the window rightward."},"source":{"file":"tmux/window_resize.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.WindowResizeDirectionRight","product":"core","slug":"tmux-windowresizedirectionright"},{"id":"tmux.ResizeWindowRequest","name":"ResizeWindowRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ResizeWindowRequest selects one directional, manual, expand, or shrink operation. Height and Width may be set together. A zero request asks tmux to reapply the current manual size. Direction requires a positive Adjustment; that pair, dimensions, Expand, and Shrink are mutually exclusive and are validated before execution. Zero Adjustment, Height, and Width omit their modes; nonzero values must be positive. The request is supported on tmux 3.2a or later."},"source":{"file":"tmux/window_resize.go","line":33,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizeWindowRequest","product":"core","slug":"tmux-resizewindowrequest"},{"id":"tmux.ResizeWindowRequest.Direction","name":"Direction","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"WindowResizeDirection","doc":{"summary":"Direction selects a directional adjustment; zero selects another mode."},"source":{"file":"tmux/window_resize.go","line":35,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizeWindowRequest.Direction","product":"core","slug":"tmux-resizewindowrequest-direction"},{"id":"tmux.ResizeWindowRequest.Adjustment","name":"Adjustment","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"int","doc":{"summary":"Adjustment is the required positive amount for Direction; zero omits it."},"source":{"file":"tmux/window_resize.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizeWindowRequest.Adjustment","product":"core","slug":"tmux-resizewindowrequest-adjustment"},{"id":"tmux.ResizeWindowRequest.Height","name":"Height","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"int","doc":{"summary":"Height sets a positive manual height; zero preserves the current height."},"source":{"file":"tmux/window_resize.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizeWindowRequest.Height","product":"core","slug":"tmux-resizewindowrequest-height"},{"id":"tmux.ResizeWindowRequest.Width","name":"Width","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"int","doc":{"summary":"Width sets a positive manual width; zero preserves the current width."},"source":{"file":"tmux/window_resize.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizeWindowRequest.Width","product":"core","slug":"tmux-resizewindowrequest-width"},{"id":"tmux.ResizeWindowRequest.Expand","name":"Expand","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Expand sets the window to the size of the largest session containing it."},"source":{"file":"tmux/window_resize.go","line":43,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizeWindowRequest.Expand","product":"core","slug":"tmux-resizewindowrequest-expand"},{"id":"tmux.ResizeWindowRequest.Shrink","name":"Shrink","kind":"attribute","modifiers":[],"parent":"tmux.ResizeWindowRequest","signatures":[],"type":"bool","doc":{"summary":"Shrink sets the window to the size of the smallest session containing it."},"source":{"file":"tmux/window_resize.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.ResizeWindowRequest.Shrink","product":"core","slug":"tmux-resizewindowrequest-shrink"},{"id":"tmux.Window.Resize","name":"Resize","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"ResizeWindowRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"Resize changes the stable window's size through the receiver's exact winlink. It does not select the window or promise any client focus. Resize returns a canonical freshly materialized [Window], which may use another linked session for the same WindowID. If the command succeeds but refresh fails, it returns the receiver with that error; other command failures return a zero Window. A transport or context error can be delivery-ambiguous and no rollback is attempted."},"source":{"file":"tmux/window_resize.go","line":55,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Resize","product":"core","slug":"tmux-window-resize"},{"id":"tmux.RespawnRequest","name":"RespawnRequest","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"RespawnRequest configures restarting a window's or pane's process on tmux 3.2a or later. Its zero value reuses the stored command and directory and requires the target process to be inactive. Nil pointer fields omit their options; nonnil pointers are explicit, including empty strings. There are no mutually exclusive fields. Arguments and environment entries are validated before execution.","body":"Methods read pointer and map values during argument construction; do not\nmutate them concurrently."},"source":{"file":"tmux/window_respawn.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RespawnRequest","product":"core","slug":"tmux-respawnrequest"},{"id":"tmux.RespawnRequest.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"tmux.RespawnRequest","signatures":[],"type":"*string","doc":{"summary":"Command is omitted when nil so tmux reuses the stored command. A nonnil empty string remains an explicit operand."},"source":{"file":"tmux/window_respawn.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RespawnRequest.Command","product":"core","slug":"tmux-respawnrequest-command"},{"id":"tmux.RespawnRequest.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"tmux.RespawnRequest","signatures":[],"type":"*string","doc":{"summary":"StartDirectory expands ~ and ~/... for the current user. Nil reuses the stored directory; a nonnil empty string selects the current directory."},"source":{"file":"tmux/window_respawn.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RespawnRequest.StartDirectory","product":"core","slug":"tmux-respawnrequest-startdirectory"},{"id":"tmux.RespawnRequest.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"tmux.RespawnRequest","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is emitted in lexically sorted key order; nil and an empty map both add no environment entries."},"source":{"file":"tmux/window_respawn.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RespawnRequest.Environment","product":"core","slug":"tmux-respawnrequest-environment"},{"id":"tmux.RespawnRequest.Kill","name":"Kill","kind":"attribute","modifiers":[],"parent":"tmux.RespawnRequest","signatures":[],"type":"bool","doc":{"summary":"Kill terminates an active target process before restarting it."},"source":{"file":"tmux/window_respawn.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.RespawnRequest.Kill","product":"core","slug":"tmux-respawnrequest-kill"},{"id":"tmux.Window.Respawn","name":"Respawn","kind":"method","modifiers":[],"parent":"tmux.Window","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"request","type":"RespawnRequest"}],"returns":"(Window, error)"}],"doc":{"summary":"Respawn restarts the stable window process through the receiver's exact winlink. It does not select the window or promise any client focus. Respawn returns a canonical freshly materialized [Window], which may use another linked session for the same WindowID. If the command succeeds but refresh fails, it returns the receiver with that error; earlier failures return zero. Completed stderr produces a redacted [CommandError]; nonzero exits without stderr are followed by refresh."},"source":{"file":"tmux/window_respawn.go","line":39,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmux.Window.Respawn","product":"core","slug":"tmux-window-respawn"},{"id":"tmuxtest.ControlMode","name":"ControlMode","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ControlMode is an attached tmux control client for real-tmux tests. It owns one stdout reader and a temporary-file spool, which preserves unread protocol output until [ControlMode.Close] releases it. Instances come from [NewControlMode]; do not construct them directly or read concurrently."},"source":{"file":"tmux/tmuxtest/control.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ControlMode","product":"core","slug":"tmuxtest-controlmode"},{"id":"tmuxtest.NewControlMode","name":"NewControlMode","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"server","type":"tmux.Server"},{"name":"session","type":"tmux.Session"}],"returns":"*ControlMode"}],"doc":{"summary":"NewControlMode starts a [ControlMode] attached to session and registers cleanup with t. It requires an explicitly configured process environment and validates that session belongs to server. The client pins the server's frozen effective socket path. Validation or startup failures call [testing.TB.Fatal]. ctx bounds startup and registration only, not the returned client's lifetime."},"source":{"file":"tmux/tmuxtest/control.go","line":49,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.NewControlMode","product":"core","slug":"tmuxtest-newcontrolmode"},{"id":"tmuxtest.ControlMode.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts an idempotent shutdown and waits within ctx. Concurrent calls join the same shutdown. If ctx ends after shutdown starts, shutdown continues and a later call may wait for completion; an already-ended ctx does not start shutdown."},"source":{"file":"tmux/tmuxtest/control.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ControlMode.CloseContext","product":"core","slug":"tmuxtest-controlmode-closecontext"},{"id":"tmuxtest.ControlMode.ClientName","name":"ClientName","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[],"returns":"tmux.ClientName"}],"doc":{"summary":"ClientName returns the tmux-assigned identity captured at registration."},"source":{"file":"tmux/tmuxtest/control.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ControlMode.ClientName","product":"core","slug":"tmuxtest-controlmode-clientname"},{"id":"tmuxtest.ControlMode.Server","name":"Server","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[],"returns":"tmux.Server"}],"doc":{"summary":"Server returns the validated server handle captured at construction."},"source":{"file":"tmux/tmuxtest/control.go","line":93,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ControlMode.Server","product":"core","slug":"tmuxtest-controlmode-server"},{"id":"tmuxtest.ControlMode.Session","name":"Session","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[],"returns":"tmux.Session"}],"doc":{"summary":"Session returns the validated session handle captured at construction."},"source":{"file":"tmux/tmuxtest/control.go","line":98,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ControlMode.Session","product":"core","slug":"tmuxtest-controlmode-session"},{"id":"tmuxtest.ControlMode.Read","name":"Read","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"data","type":"[]byte"}],"returns":"(int, error)"}],"doc":{"summary":"Read reads control-protocol output within ctx. Exactly one caller may read at a time. After the client exits, callers may drain preserved output through [io.EOF]; after [ControlMode.Close], a non-empty Read returns [os.ErrClosed]. It returns ctx errors while waiting for output."},"source":{"file":"tmux/tmuxtest/control.go","line":106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ControlMode.Read","product":"core","slug":"tmuxtest-controlmode-read"},{"id":"tmuxtest.ControlMode.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Wait blocks until the control client exits or ctx ends. It does not stop or close the client; use [ControlMode.Close] to release it."},"source":{"file":"tmux/tmuxtest/control.go","line":112,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ControlMode.Wait","product":"core","slug":"tmuxtest-controlmode-wait"},{"id":"tmuxtest.ControlMode.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmuxtest.ControlMode","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the control client and releases its output spool. It is safe to call concurrently and more than once."},"source":{"file":"tmux/tmuxtest/control.go","line":123,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ControlMode.Close","product":"core","slug":"tmuxtest-controlmode-close"},{"id":"tmuxtest.ServerOptions","name":"ServerOptions","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerOptions configures a harness-owned [tmux.Server]. All inputs are copied before filesystem or process operations, so callers retain ownership."},"source":{"file":"tmux/tmuxtest/harness.go","line":97,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ServerOptions","product":"core","slug":"tmuxtest-serveroptions"},{"id":"tmuxtest.ServerOptions.Binary","name":"Binary","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"string","doc":{"summary":"Binary is the tmux executable. An empty value resolves tmux from PATH."},"source":{"file":"tmux/tmuxtest/harness.go","line":99,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ServerOptions.Binary","product":"core","slug":"tmuxtest-serveroptions-binary"},{"id":"tmuxtest.ServerOptions.Config","name":"Config","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"[]byte","doc":{"summary":"Config is appended to the harness-owned config file; it cannot replace the private file that prevents user configuration from loading."},"source":{"file":"tmux/tmuxtest/harness.go","line":102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ServerOptions.Config","product":"core","slug":"tmuxtest-serveroptions-config"},{"id":"tmuxtest.ServerOptions.ProcessEnvironment","name":"ProcessEnvironment","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"[]string","doc":{"summary":"ProcessEnvironment supplies the server environment. Nil snapshots the current process environment, while a non-nil empty slice remains empty. Tmux targeting variables are removed in either case."},"source":{"file":"tmux/tmuxtest/harness.go","line":106,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ServerOptions.ProcessEnvironment","product":"core","slug":"tmuxtest-serveroptions-processenvironment"},{"id":"tmuxtest.ServerOptions.InitialSession","name":"InitialSession","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"*tmux.NewSessionRequest","doc":{"summary":"InitialSession starts the daemon with this copied request. Nil returns a lazy bare server; a later tmux command may start it."},"source":{"file":"tmux/tmuxtest/harness.go","line":109,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ServerOptions.InitialSession","product":"core","slug":"tmuxtest-serveroptions-initialsession"},{"id":"tmuxtest.ServerOptions.FixedShell","name":"FixedShell","kind":"attribute","modifiers":[],"parent":"tmuxtest.ServerOptions","signatures":[],"type":"bool","doc":{"summary":"FixedShell gives panes without an explicit command a POSIX shell with no startup files and the prompt ShellPrompt. RunInPane sets it; the default preserves tmux process behavior for tests that need it."},"source":{"file":"tmux/tmuxtest/harness.go","line":113,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ServerOptions.FixedShell","product":"core","slug":"tmuxtest-serveroptions-fixedshell"},{"id":"tmuxtest.ShellPrompt","name":"ShellPrompt","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ShellPrompt is the prompt drawn when [ServerOptions.FixedShell] is enabled."},"source":{"file":"tmux/tmuxtest/harness.go","line":117,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ShellPrompt","product":"core","slug":"tmuxtest-shellprompt"},{"id":"tmuxtest.SuiteRootTagVariable","name":"SuiteRootTagVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"SuiteRootTagVariable names the environment variable that tags a suite's temporary root. go test runs packages in parallel and every suite among them creates a root beside the others, so a test spawning a child suite sets this to tell its child's root from theirs."},"source":{"file":"tmux/tmuxtest/harness.go","line":224,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.SuiteRootTagVariable","product":"core","slug":"tmuxtest-suiteroottagvariable"},{"id":"tmuxtest.Main","name":"Main","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"m","type":"*testing.M"}],"returns":"int"}],"doc":{"summary":"Main runs the one-call package lifecycle for tmuxtest. It prepares short temporary paths, redirects [suiteEnvironment] into them, runs m, cleans registered servers, restores the environment, and returns the final status. TestMain should return its result through [os.Exit]."},"source":{"file":"tmux/tmuxtest/harness.go","line":237,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.Main","product":"core","slug":"tmuxtest-main"},{"id":"tmuxtest.NewServer","name":"NewServer","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"}],"returns":"tmux.Server"}],"doc":{"summary":"NewServer starts an isolated [tmux.Server] with a session named \"work\". Startup uses ctx and the harness timeout, whichever ends first. It registers bounded cleanup with t; setup failures call [testing.TB.Fatal]. The context does not govern later server cleanup or daemon lifetime."},"source":{"file":"tmux/tmuxtest/harness.go","line":307,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.NewServer","product":"core","slug":"tmuxtest-newserver"},{"id":"tmuxtest.NewServerWithOptions","name":"NewServerWithOptions","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"options","type":"ServerOptions"}],"returns":"tmux.Server"}],"doc":{"summary":"NewServerWithOptions prepares an isolated harness-owned [tmux.Server] from options. Initial startup uses ctx and the harness timeout, whichever ends first. The daemon starts only when [ServerOptions.InitialSession] is non-nil or a later tmux command starts it. It registers bounded cleanup with t; setup failures call [testing.TB.Fatal]. The context does not govern later cleanup or daemon lifetime."},"source":{"file":"tmux/tmuxtest/harness.go","line":320,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.NewServerWithOptions","product":"core","slug":"tmuxtest-newserverwithoptions"},{"id":"tmuxtest.PTYProcess","name":"PTYProcess","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"PTYProcess is a test subprocess that owns an isolated controlling terminal and a memory-backed transcript. It comes from [StartPTYProcess]. Output may be read concurrently through [PTYProcess.Output]; writes are serialized."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.PTYProcess","product":"core","slug":"tmuxtest-ptyprocess"},{"id":"tmuxtest.StartPTYProcess","name":"StartPTYProcess","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"binary","type":"string"},{"name":"arguments","type":"[]string"},{"name":"environment","type":"[]string"}],"returns":"*PTYProcess"}],"doc":{"summary":"StartPTYProcess starts binary with a harness-owned controlling terminal and registers bounded cleanup with t. Its start context owns the child lifetime: canceling ctx terminates the child. Arguments and environment are copied. A nil environment inherits the current process environment; a non-nil empty environment remains empty. binary runs directly without a shell. The PTY backend is supported on Linux only; unsupported platforms call [testing.TB.Fatal]. Setup failures also call [testing.TB.Fatal]."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.StartPTYProcess","product":"core","slug":"tmuxtest-startptyprocess"},{"id":"tmuxtest.PTYProcess.Done","name":"Done","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[],"returns":"<-chan struct{}"}],"doc":{"summary":"Done is closed when the subprocess exits. It can close before the terminal reader has added the final bytes to [PTYProcess.Output]."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":109,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.PTYProcess.Done","product":"core","slug":"tmuxtest-ptyprocess-done"},{"id":"tmuxtest.PTYProcess.Write","name":"Write","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"input","type":"[]byte"}],"returns":"(int, error)"}],"doc":{"summary":"Write sends terminal input to the subprocess within ctx. Writes are serialized and can be partial. A waiting caller may cancel before acquiring the writer, and an active write observes ctx cancellation."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":114,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.PTYProcess.Write","product":"core","slug":"tmuxtest-ptyprocess-write"},{"id":"tmuxtest.PTYProcess.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"Wait waits for process completion and the final output drain, or ctx cancellation. A successful Wait guarantees that [PTYProcess.Output] contains the completed transcript."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":156,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.PTYProcess.Wait","product":"core","slug":"tmuxtest-ptyprocess-wait"},{"id":"tmuxtest.PTYProcess.Output","name":"Output","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[],"returns":"[]byte"}],"doc":{"summary":"Output returns a fresh copy of terminal output collected so far. A successful [PTYProcess.Wait] guarantees that the returned transcript includes the final drain."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":173,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.PTYProcess.Output","product":"core","slug":"tmuxtest-ptyprocess-output"},{"id":"tmuxtest.PTYProcess.Close","name":"Close","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops the subprocess if needed and releases the PTY master. It is safe to call concurrently and more than once."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":177,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.PTYProcess.Close","product":"core","slug":"tmuxtest-ptyprocess-close"},{"id":"tmuxtest.PTYProcess.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"tmuxtest.PTYProcess","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts an idempotent shutdown and waits within ctx. Concurrent calls join the same shutdown. If ctx ends after shutdown starts, shutdown continues and a later call may wait for completion; an already-ended ctx does not start shutdown."},"source":{"file":"tmux/tmuxtest/pty_process.go","line":189,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.PTYProcess.CloseContext","product":"core","slug":"tmuxtest-ptyprocess-closecontext"},{"id":"tmuxtest.TemporaryNamePrefix","name":"TemporaryNamePrefix","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"TemporaryNamePrefix prefixes names generated by [NewSession] and [NewWindow]."},"source":{"file":"tmux/tmuxtest/resources.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.TemporaryNamePrefix","product":"core","slug":"tmuxtest-temporarynameprefix"},{"id":"tmuxtest.NewSession","name":"NewSession","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"server","type":"tmux.Server"},{"name":"request","type":"tmux.NewSessionRequest"}],"returns":"tmux.Session"}],"doc":{"summary":"NewSession creates a test-owned [tmux.Session] and registers cleanup against its stable ID. An empty [tmux.NewSessionRequest.Name] receives a collision-checked temporary name. The request and referenced values are copied before tmux is called, and setup failures call [testing.TB.Fatal]. Cleanup belongs to t rather than ctx and continues to target the session if it is renamed."},"source":{"file":"tmux/tmuxtest/resources.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.NewSession","product":"core","slug":"tmuxtest-newsession"},{"id":"tmuxtest.NewWindow","name":"NewWindow","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"session","type":"tmux.Session"},{"name":"request","type":"tmux.NewWindowRequest"}],"returns":"tmux.Window"}],"doc":{"summary":"NewWindow creates a test-owned [tmux.Window] and registers cleanup against its stable ID. A nil [tmux.NewWindowRequest.Name] receives a collision-checked temporary name; an empty non-nil name remains explicit. The request and referenced values are copied before tmux is called, and setup failures call [testing.TB.Fatal]. Cleanup belongs to t rather than ctx and follows the window if it is moved."},"source":{"file":"tmux/tmuxtest/resources.go","line":69,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.NewWindow","product":"core","slug":"tmuxtest-newwindow"},{"id":"tmuxtest.Screen","name":"Screen","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"}],"returns":"[]string"}],"doc":{"summary":"Screen returns the pane's visible lines, top to bottom, with tmux's trailing blank lines removed.","body":"Scrolled-out output is excluded. Use [tmux.Pane.Capture] with\n[tmux.CaptureBoundary] to read scrollback.\n\nRead failures call [testing.TB.Fatal]."},"source":{"file":"tmux/tmuxtest/screen.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.Screen","product":"core","slug":"tmuxtest-screen"},{"id":"tmuxtest.WaitForText","name":"WaitForText","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"text","type":"string"}]}],"doc":{"summary":"WaitForText blocks until some line of the pane's screen contains text.","body":"A pane that never shows text fails the test with the screen it last read."},"source":{"file":"tmux/tmuxtest/screen.go","line":41,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.WaitForText","product":"core","slug":"tmuxtest-waitfortext"},{"id":"tmuxtest.WaitForLine","name":"WaitForLine","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"line","type":"string"}]}],"doc":{"summary":"WaitForLine blocks until some line of the pane's screen is exactly line.","body":"A pane that never shows line fails the test with the screen it last read."},"source":{"file":"tmux/tmuxtest/screen.go","line":57,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.WaitForLine","product":"core","slug":"tmuxtest-waitforline"},{"id":"tmuxtest.WaitForScreen","name":"WaitForScreen","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"want","type":"string"},{"name":"match","type":"func(screen []string) bool"}]}],"doc":{"summary":"WaitForScreen blocks until the pane's screen satisfies match.","body":"want is the noun phrase used in the failure message.\n\nmatch receives a newly read screen and must not retain it."},"source":{"file":"tmux/tmuxtest/screen.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.WaitForScreen","product":"core","slug":"tmuxtest-waitforscreen"},{"id":"tmuxtest.WaitForShellReady","name":"WaitForShellReady","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"}]}],"doc":{"summary":"WaitForShellReady blocks until the pane first shows output. With [ServerOptions.FixedShell], that expected first output is the harness prompt and serves as readiness evidence; custom shell startup output may not.","body":"[RunInPane] calls it, and a test building its own pane should too."},"source":{"file":"tmux/tmuxtest/screen.go","line":103,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.WaitForShellReady","product":"core","slug":"tmuxtest-waitforshellready"},{"id":"tmuxtest.Type","name":"Type","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"command","type":"string"}]}],"doc":{"summary":"Type sends command to the pane and submits it, as a person at the keyboard would.","body":"command is sent literally. Type returns when tmux accepts the keys, before the\nshell finishes; follow it with a wait when completion matters."},"source":{"file":"tmux/tmuxtest/screen.go","line":115,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.Type","product":"core","slug":"tmuxtest-type"},{"id":"tmuxtest.TypeAndWait","name":"TypeAndWait","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"pane","type":"tmux.Pane"},{"name":"command","type":"string"}]}],"doc":{"summary":"TypeAndWait sends command to the pane and blocks until it has finished.","body":"It appends and waits for a unique marker whether the command succeeds or\nfails. It does not return the command's exit status."},"source":{"file":"tmux/tmuxtest/screen.go","line":129,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.TypeAndWait","product":"core","slug":"tmuxtest-typeandwait"},{"id":"tmuxtest.RunInPane","name":"RunInPane","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"t","type":"testing.TB"},{"name":"command","type":"string"}],"returns":"tmux.Pane"}],"doc":{"summary":"RunInPane creates an isolated pane, waits for its startup-file-free POSIX shell, and submits command with [Type]. It does not wait for command to start or finish. Resources belong to t; setup failures call [testing.TB.Fatal]. Use [NewServerWithOptions] for custom topology or configuration."},"source":{"file":"tmux/tmuxtest/screen.go","line":155,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.RunInPane","product":"core","slug":"tmuxtest-runinpane"},{"id":"tmuxtest.ScriptedCommand","name":"ScriptedCommand","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ScriptedCommand is one answer a scripted tmux gives. The first matching entry wins, and an invocation nothing matches exits 1 saying so."},"source":{"file":"tmux/tmuxtest/scripted.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ScriptedCommand","product":"core","slug":"tmuxtest-scriptedcommand"},{"id":"tmuxtest.ScriptedCommand.Contains","name":"Contains","kind":"attribute","modifiers":[],"parent":"tmuxtest.ScriptedCommand","signatures":[],"type":"[]string","doc":{"summary":"Contains selects the invocations this entry answers: one matches when its arguments contain every string listed, so \"list-sessions\" answers that subcommand whatever flags surround it. Empty matches every invocation."},"source":{"file":"tmux/tmuxtest/scripted.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ScriptedCommand.Contains","product":"core","slug":"tmuxtest-scriptedcommand-contains"},{"id":"tmuxtest.ScriptedCommand.Stdout","name":"Stdout","kind":"attribute","modifiers":[],"parent":"tmuxtest.ScriptedCommand","signatures":[],"type":"string","doc":{"summary":"Stdout is written to standard output exactly, newlines included."},"source":{"file":"tmux/tmuxtest/scripted.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ScriptedCommand.Stdout","product":"core","slug":"tmuxtest-scriptedcommand-stdout"},{"id":"tmuxtest.ScriptedCommand.Stderr","name":"Stderr","kind":"attribute","modifiers":[],"parent":"tmuxtest.ScriptedCommand","signatures":[],"type":"string","doc":{"summary":"Stderr is written to standard error exactly, newlines included. This package reads a completed failure from stderr rather than from an exit code, so an entry standing in for one sets this."},"source":{"file":"tmux/tmuxtest/scripted.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ScriptedCommand.Stderr","product":"core","slug":"tmuxtest-scriptedcommand-stderr"},{"id":"tmuxtest.ScriptedCommand.ExitCode","name":"ExitCode","kind":"attribute","modifiers":[],"parent":"tmuxtest.ScriptedCommand","signatures":[],"type":"int","doc":{"summary":"ExitCode is the status the invocation exits with."},"source":{"file":"tmux/tmuxtest/scripted.go","line":26,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ScriptedCommand.ExitCode","product":"core","slug":"tmuxtest-scriptedcommand-exitcode"},{"id":"tmuxtest.ScriptedTmux","name":"ScriptedTmux","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"t","type":"testing.TB"},{"name":"script","type":"ScriptedCommand"}],"returns":"string"}],"doc":{"summary":"ScriptedTmux writes an executable that answers tmux invocations from script and returns its absolute path, for [tmux.ServerOptions.Binary]. It is how a test drives code that uses this package without a tmux to drive:","body":"server, err := tmux.NewServer(tmux.ServerOptions{\n\tBinary: tmuxtest.ScriptedTmux(t,\n\t\ttmuxtest.ScriptedCommand{Contains: []string{\"-V\"}, Stdout: \"tmux 3.7\\n\"},\n\t\ttmuxtest.ScriptedCommand{\n\t\t\tContains: []string{\"kill-pane\"},\n\t\t\tStderr:   \"can't find pane: %7\\n\",\n\t\t\tExitCode: 1,\n\t\t},\n\t),\n})\n\nThe executable is removed with the test. It answers commands only: opening a\ncontrol connection or a notification stream speaks tmux's control protocol,\nwhich a script cannot, so code that opens one needs [NewServer] and a real\ntmux."},"source":{"file":"tmux/tmuxtest/scripted.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.ScriptedTmux","product":"core","slug":"tmuxtest-scriptedtmux"},{"id":"tmuxtest.WaitFor","name":"WaitFor","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"interval","type":"time.Duration"},{"name":"condition","type":"func(context.Context) (bool, error)"}],"returns":"error"}],"doc":{"summary":"WaitFor checks condition serially and immediately, then after each interval, until it succeeds, returns an error, or ctx ends. It validates interval, condition, and ctx in that order: interval must be positive, condition must be non-nil, and an already-ended context prevents every check. Condition errors and context errors are returned unchanged. A running condition receives ctx and must observe it itself; WaitFor cannot interrupt the condition."},"source":{"file":"tmux/tmuxtest/wait.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxtest.WaitFor","product":"core","slug":"tmuxtest-waitfor"},{"id":"tmuxq.Filter","name":"Filter","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Filter is anything that compiles itself into a predicate over T, which is what the tmux package's generated model filters do. It exists so a filter and a query can meet without this package naming a model."},"source":{"file":"tmuxq/filter.go","line":8,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.Filter","product":"core","slug":"tmuxq-filter"},{"id":"tmuxq.Matching","name":"Matching","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"[]T"},{"name":"filter","type":"Filter[T]"}],"returns":"([]T, error)","typeParams":["T any"]}],"doc":{"summary":"Matching returns a fresh slice of shallow copies for values that filter accepts, retaining their source order, and reports the one error a filter can have rather than leaving it for the caller to unpack first. It evaluates every input value, so a no-match result is an empty slice.","body":"active, err := tmuxq.Matching(snapshot.Panes(), tmux.PaneActiveIs(true))"},"source":{"file":"tmuxq/filter.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.Matching","product":"core","slug":"tmuxq-matching"},{"id":"tmuxq.MatchingSeq","name":"MatchingSeq","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"iter.Seq[T]"},{"name":"filter","type":"Filter[T]"}],"returns":"(iter.Seq[T], error)","typeParams":["T any"]}],"doc":{"summary":"MatchingSeq returns a lazy sequence of shallow copies for values that filter accepts, retaining source order. The filter is compiled before iteration begins, so an invalid filter is an error here rather than a sequence that yields nothing."},"source":{"file":"tmuxq/filter.go","line":32,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.MatchingSeq","product":"core","slug":"tmuxq-matchingseq"},{"id":"tmuxq.ErrNoMatch","name":"ErrNoMatch","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrNoMatch identifies an ExactlyOne or ExactlyOneSeq query with no matching value. Cardinality errors can be checked with errors.Is."},"source":{"file":"tmuxq/query.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.ErrNoMatch","product":"core","slug":"tmuxq-errnomatch"},{"id":"tmuxq.ErrMultipleMatches","name":"ErrMultipleMatches","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrMultipleMatches identifies an ExactlyOne or ExactlyOneSeq query with more than one matching value. The queries stop when they find the second match. Cardinality errors can be checked with errors.Is."},"source":{"file":"tmuxq/query.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.ErrMultipleMatches","product":"core","slug":"tmuxq-errmultiplematches"},{"id":"tmuxq.Where","name":"Where","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"[]T"},{"name":"predicate","type":"func(*T) bool"}],"returns":"[]T","typeParams":["T any"]}],"doc":{"summary":"Where returns a fresh slice of shallow copies for values accepted by predicate, retaining their source order. It evaluates every input value, so a no-match result is an empty slice."},"source":{"file":"tmuxq/query.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.Where","product":"core","slug":"tmuxq-where"},{"id":"tmuxq.First","name":"First","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"[]T"},{"name":"predicate","type":"func(*T) bool"}],"returns":"(T, bool)","typeParams":["T any"]}],"doc":{"summary":"First returns a shallow copy of the first source-ordered value accepted by predicate and stops evaluating later values. If no value matches, it returns the zero value of T and false."},"source":{"file":"tmuxq/query.go","line":37,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.First","product":"core","slug":"tmuxq-first"},{"id":"tmuxq.ExactlyOne","name":"ExactlyOne","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"[]T"},{"name":"predicate","type":"func(*T) bool"}],"returns":"(T, error)","typeParams":["T any"]}],"doc":{"summary":"ExactlyOne returns a shallow copy when exactly one source-ordered value is accepted by predicate. It examines values until source exhaustion confirms a sole match, or stops at the second match. It returns the zero value of T with [ErrNoMatch] for no matches or [ErrMultipleMatches] for multiple matches; callers can classify either error with [errors.Is]."},"source":{"file":"tmuxq/query.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.ExactlyOne","product":"core","slug":"tmuxq-exactlyone"},{"id":"tmuxq.WhereSeq","name":"WhereSeq","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"iter.Seq[T]"},{"name":"predicate","type":"func(*T) bool"}],"returns":"iter.Seq[T]","typeParams":["T any"]}],"doc":{"summary":"WhereSeq returns a lazy sequence of shallow copies for values accepted by predicate, retaining source order. It does not pull values until the result is iterated. When its consumer stops, WhereSeq stops pulling from values. For an infinite input, it runs until its consumer stops."},"source":{"file":"tmuxq/query.go","line":79,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.WhereSeq","product":"core","slug":"tmuxq-whereseq"},{"id":"tmuxq.FirstSeq","name":"FirstSeq","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"iter.Seq[T]"},{"name":"predicate","type":"func(*T) bool"}],"returns":"(T, bool)","typeParams":["T any"]}],"doc":{"summary":"FirstSeq returns a shallow copy of the first source-ordered sequence value accepted by predicate and stops pulling later values. If no value matches, it returns the zero value of T and false. With an infinite input that never matches, FirstSeq does not return."},"source":{"file":"tmuxq/query.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.FirstSeq","product":"core","slug":"tmuxq-firstseq"},{"id":"tmuxq.ExactlyOneSeq","name":"ExactlyOneSeq","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"values","type":"iter.Seq[T]"},{"name":"predicate","type":"func(*T) bool"}],"returns":"(T, error)","typeParams":["T any"]}],"doc":{"summary":"ExactlyOneSeq returns a shallow copy when exactly one source-ordered sequence value is accepted by predicate. It stops pulling at the second match. If input ends with no matches, it returns the zero value of T with [ErrNoMatch]; if it finds a second match, it returns the zero value of T with [ErrMultipleMatches]. Callers can classify either error with [errors.Is]. With an infinite input, ExactlyOneSeq returns only after a second match; it cannot confirm a no-match or exactly-one result without source exhaustion."},"source":{"file":"tmuxq/query.go","line":112,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"tmuxq.ExactlyOneSeq","product":"core","slug":"tmuxq-exactlyoneseq"},{"id":"workspace.Workspace.InitialSessionRequest","name":"InitialSessionRequest","kind":"method","modifiers":[],"parent":"workspace.Workspace","signatures":[{"params":[],"returns":"(tmux.NewSessionRequest, error)"}],"doc":{"summary":"InitialSessionRequest validates w and returns the request that creates its session and initial window. Use the resulting materialized session with [BuildInto] to continue the build over a caller-owned transport."},"source":{"file":"workspace/builder.go","line":17,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.InitialSessionRequest","product":"workspace","apiScope":"exported","slug":"workspace-workspace-initialsessionrequest"},{"id":"workspace.Build","name":"Build","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"server","type":"tmux.Server"},{"name":"workspace","type":"Workspace"}],"returns":"(tmux.Session, error)"}],"doc":{"summary":"Build creates the workspace on server and returns the created session.","body":"Build is not atomic. A failure after session creation returns that session;\ncompleted mutations remain in tmux. Command failures are not normalized.\nEvery layout is checked against the selected daemon and desired pane count\nbefore session creation. tmux validates geometry when applying each layout.\n\nBuild creates the session and an attached control connection in one process,\nuses that connection for the build, and closes it before returning. The\nreturned Session is not bound to the closed connection. Build verifies that\nthe session remains reachable after closing it. An attached connection may\nfire client hooks and policies.\n\nEach pane receives workspace, window, and pane CommandsBefore, then its own\nCommands. Sleep values pause Build rather than the pane."},"source":{"file":"workspace/builder.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Build","product":"workspace","apiScope":"exported","slug":"workspace-build"},{"id":"workspace.BuildInto","name":"BuildInto","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"session","type":"tmux.Session"},{"name":"workspace","type":"Workspace"}],"returns":"error"}],"doc":{"summary":"BuildInto populates the initial session described by workspace. The session must already have been created from [Workspace.InitialSessionRequest]. BuildInto uses the session's existing server and transport; it neither creates a session nor opens or owns a connection.","body":"BuildInto is not atomic. A failure leaves completed mutations in tmux.\nEvery layout is checked before changing the initial session."},"source":{"file":"workspace/builder.go","line":87,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.BuildInto","product":"workspace","apiScope":"exported","slug":"workspace-buildinto"},{"id":"workspace.Command","name":"Command","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Command is one command to run in a pane. YAML accepts either a bare string or a mapping, so \"echo hi\" and {cmd: echo hi, sleep_before: 2} are both commands."},"source":{"file":"workspace/command.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Command","product":"workspace","apiScope":"exported","slug":"workspace-command"},{"id":"workspace.Command.Command","name":"Command","kind":"attribute","modifiers":[],"parent":"workspace.Command","signatures":[],"type":"string","doc":{"summary":"Command is the text typed into the pane."},"source":{"file":"workspace/command.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Command.Command","product":"workspace","apiScope":"exported","slug":"workspace-command-command"},{"id":"workspace.Command.SleepBefore","name":"SleepBefore","kind":"attribute","modifiers":[],"parent":"workspace.Command","signatures":[],"type":"time.Duration","doc":{"summary":"SleepBefore delays this command. YAML expresses the duration in seconds, so 0.5 is half a second."},"source":{"file":"workspace/command.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Command.SleepBefore","product":"workspace","apiScope":"exported","slug":"workspace-command-sleepbefore"},{"id":"workspace.Command.SleepAfter","name":"SleepAfter","kind":"attribute","modifiers":[],"parent":"workspace.Command","signatures":[],"type":"time.Duration","doc":{"summary":"SleepAfter delays the commands that follow this one, in the same units."},"source":{"file":"workspace/command.go","line":20,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Command.SleepAfter","product":"workspace","apiScope":"exported","slug":"workspace-command-sleepafter"},{"id":"workspace.Command.Enter","name":"Enter","kind":"attribute","modifiers":[],"parent":"workspace.Command","signatures":[],"type":"*Bool","doc":{"summary":"Enter reports whether to press Enter after the command. Nil presses it, matching tmuxp, where omitting enter runs the command."},"source":{"file":"workspace/command.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Command.Enter","product":"workspace","apiScope":"exported","slug":"workspace-command-enter"},{"id":"workspace.Command.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Command","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes a command written as a bare string or as a mapping."},"source":{"file":"workspace/command.go","line":29,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Command.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-command-unmarshalyaml"},{"id":"workspace.ErrInvalidWorkspace","name":"ErrInvalidWorkspace","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInvalidWorkspace matches parse and validation failures, but not tmux command failures from [Build]."},"source":{"file":"workspace/workspace.go","line":45,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.ErrInvalidWorkspace","product":"workspace","apiScope":"exported","slug":"workspace-errinvalidworkspace"},{"id":"workspace.Workspace","name":"Workspace","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Workspace is one tmuxp-style session description."},"source":{"file":"workspace/workspace.go","line":48,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace","product":"workspace","apiScope":"exported","slug":"workspace-workspace"},{"id":"workspace.Workspace.SessionName","name":"SessionName","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"string","doc":{"summary":"SessionName names the created session. It is required."},"source":{"file":"workspace/workspace.go","line":50,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.SessionName","product":"workspace","apiScope":"exported","slug":"workspace-workspace-sessionname"},{"id":"workspace.Workspace.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"string","doc":{"summary":"StartDirectory is the default working directory for every window and pane that does not set its own."},"source":{"file":"workspace/workspace.go","line":53,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.StartDirectory","product":"workspace","apiScope":"exported","slug":"workspace-workspace-startdirectory"},{"id":"workspace.Workspace.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is written to the session after its initial pane exists and before later windows are created."},"source":{"file":"workspace/workspace.go","line":56,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.Environment","product":"workspace","apiScope":"exported","slug":"workspace-workspace-environment"},{"id":"workspace.Workspace.Options","name":"Options","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"map[string]string","doc":{"summary":"Options are applied after session creation. tmux resolves window-option names against the session's current window."},"source":{"file":"workspace/workspace.go","line":59,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.Options","product":"workspace","apiScope":"exported","slug":"workspace-workspace-options"},{"id":"workspace.Workspace.GlobalOptions","name":"GlobalOptions","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"map[string]string","doc":{"summary":"GlobalOptions are applied after the initial window exists and before later windows are created."},"source":{"file":"workspace/workspace.go","line":62,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.GlobalOptions","product":"workspace","apiScope":"exported","slug":"workspace-workspace-globaloptions"},{"id":"workspace.Workspace.CommandsBefore","name":"CommandsBefore","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"[]Command","doc":{"summary":"CommandsBefore run in every pane before that pane's own commands. Window and pane entries add to this list rather than replacing it."},"source":{"file":"workspace/workspace.go","line":65,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.CommandsBefore","product":"workspace","apiScope":"exported","slug":"workspace-workspace-commandsbefore"},{"id":"workspace.Workspace.SuppressHistory","name":"SuppressHistory","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"*Bool","doc":{"summary":"SuppressHistory prefixes commands with a space unless a window or pane overrides it. Nil suppresses history, matching tmuxp."},"source":{"file":"workspace/workspace.go","line":68,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.SuppressHistory","product":"workspace","apiScope":"exported","slug":"workspace-workspace-suppresshistory"},{"id":"workspace.Workspace.Windows","name":"Windows","kind":"attribute","modifiers":[],"parent":"workspace.Workspace","signatures":[],"type":"[]Window","doc":{"summary":"Windows are created in order. A workspace needs at least one."},"source":{"file":"workspace/workspace.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.Windows","product":"workspace","apiScope":"exported","slug":"workspace-workspace-windows"},{"id":"workspace.Window","name":"Window","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Window is one window in a workspace."},"source":{"file":"workspace/workspace.go","line":74,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window","product":"workspace","apiScope":"exported","slug":"workspace-window"},{"id":"workspace.Window.Name","name":"Name","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"string","doc":{"summary":"Name is the window name. Empty lets tmux choose."},"source":{"file":"workspace/workspace.go","line":76,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.Name","product":"workspace","apiScope":"exported","slug":"workspace-window-name"},{"id":"workspace.Window.Index","name":"Index","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"*int","doc":{"summary":"Index requests an explicit winlink index. Nil uses the next free index."},"source":{"file":"workspace/workspace.go","line":78,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.Index","product":"workspace","apiScope":"exported","slug":"workspace-window-index"},{"id":"workspace.Window.Layout","name":"Layout","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"string","doc":{"summary":"Layout is a tmux layout name applied after the panes exist."},"source":{"file":"workspace/workspace.go","line":80,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.Layout","product":"workspace","apiScope":"exported","slug":"workspace-window-layout"},{"id":"workspace.Window.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"string","doc":{"summary":"StartDirectory overrides the workspace directory for this window."},"source":{"file":"workspace/workspace.go","line":82,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.StartDirectory","product":"workspace","apiScope":"exported","slug":"workspace-window-startdirectory"},{"id":"workspace.Window.Shell","name":"Shell","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"string","doc":{"summary":"Shell replaces the command the window's first pane runs."},"source":{"file":"workspace/workspace.go","line":84,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.Shell","product":"workspace","apiScope":"exported","slug":"workspace-window-shell"},{"id":"workspace.Window.Focus","name":"Focus","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"Bool","doc":{"summary":"Focus selects this window once the workspace is built."},"source":{"file":"workspace/workspace.go","line":86,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.Focus","product":"workspace","apiScope":"exported","slug":"workspace-window-focus"},{"id":"workspace.Window.SuppressHistory","name":"SuppressHistory","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"*Bool","doc":{"summary":"SuppressHistory overrides the workspace setting for this window's panes."},"source":{"file":"workspace/workspace.go","line":88,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.SuppressHistory","product":"workspace","apiScope":"exported","slug":"workspace-window-suppresshistory"},{"id":"workspace.Window.Options","name":"Options","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"map[string]string","doc":{"summary":"Options are applied after the window's initial pane exists and before additional panes are split."},"source":{"file":"workspace/workspace.go","line":91,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.Options","product":"workspace","apiScope":"exported","slug":"workspace-window-options"},{"id":"workspace.Window.OptionsAfter","name":"OptionsAfter","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"map[string]string","doc":{"summary":"OptionsAfter are window options applied once the panes exist, for settings that a later split would otherwise overwrite."},"source":{"file":"workspace/workspace.go","line":94,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.OptionsAfter","product":"workspace","apiScope":"exported","slug":"workspace-window-optionsafter"},{"id":"workspace.Window.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is written to the session after this window's initial pane exists and before additional panes are split. Repeated names keep the last value written."},"source":{"file":"workspace/workspace.go","line":98,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.Environment","product":"workspace","apiScope":"exported","slug":"workspace-window-environment"},{"id":"workspace.Window.CommandsBefore","name":"CommandsBefore","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"[]Command","doc":{"summary":"CommandsBefore run in each of this window's panes before the pane's own commands, after the workspace's."},"source":{"file":"workspace/workspace.go","line":101,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.CommandsBefore","product":"workspace","apiScope":"exported","slug":"workspace-window-commandsbefore"},{"id":"workspace.Window.Panes","name":"Panes","kind":"attribute","modifiers":[],"parent":"workspace.Window","signatures":[],"type":"[]Pane","doc":{"summary":"Panes are created in order. The first pane is the window's initial pane; each later one splits the window."},"source":{"file":"workspace/workspace.go","line":104,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.Panes","product":"workspace","apiScope":"exported","slug":"workspace-window-panes"},{"id":"workspace.Pane","name":"Pane","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Pane is one pane in a window. YAML accepts either a bare command string or a mapping, so \"echo hello\" and {shell_command: echo hello} are equivalent."},"source":{"file":"workspace/workspace.go","line":111,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane","product":"workspace","apiScope":"exported","slug":"workspace-pane"},{"id":"workspace.Pane.Commands","name":"Commands","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"[]Command","doc":{"summary":"Commands run in the pane, in order."},"source":{"file":"workspace/workspace.go","line":113,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.Commands","product":"workspace","apiScope":"exported","slug":"workspace-pane-commands"},{"id":"workspace.Pane.CommandsBefore","name":"CommandsBefore","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"[]Command","doc":{"summary":"CommandsBefore run before Commands, after the window's."},"source":{"file":"workspace/workspace.go","line":115,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.CommandsBefore","product":"workspace","apiScope":"exported","slug":"workspace-pane-commandsbefore"},{"id":"workspace.Pane.StartDirectory","name":"StartDirectory","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"string","doc":{"summary":"StartDirectory overrides the window directory for this pane."},"source":{"file":"workspace/workspace.go","line":117,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.StartDirectory","product":"workspace","apiScope":"exported","slug":"workspace-pane-startdirectory"},{"id":"workspace.Pane.Shell","name":"Shell","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"string","doc":{"summary":"Shell replaces this pane's command. On the first pane it conflicts with Window.Shell because tmux creates that pane with the window."},"source":{"file":"workspace/workspace.go","line":120,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.Shell","product":"workspace","apiScope":"exported","slug":"workspace-pane-shell"},{"id":"workspace.Pane.Focus","name":"Focus","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"Bool","doc":{"summary":"Focus selects this pane once its window is built."},"source":{"file":"workspace/workspace.go","line":122,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.Focus","product":"workspace","apiScope":"exported","slug":"workspace-pane-focus"},{"id":"workspace.Pane.SuppressHistory","name":"SuppressHistory","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"*Bool","doc":{"summary":"SuppressHistory overrides the window setting for this pane."},"source":{"file":"workspace/workspace.go","line":124,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.SuppressHistory","product":"workspace","apiScope":"exported","slug":"workspace-pane-suppresshistory"},{"id":"workspace.Pane.Environment","name":"Environment","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"map[string]string","doc":{"summary":"Environment is written to the session after all panes in the window exist and before this pane's commands are sent. Pane entries are processed in order, so repeated names keep the last value written."},"source":{"file":"workspace/workspace.go","line":128,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.Environment","product":"workspace","apiScope":"exported","slug":"workspace-pane-environment"},{"id":"workspace.Pane.Enter","name":"Enter","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"*Bool","doc":{"summary":"Enter applies to every command in this pane unless the command sets its own. Nil presses Enter, matching tmuxp."},"source":{"file":"workspace/workspace.go","line":131,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.Enter","product":"workspace","apiScope":"exported","slug":"workspace-pane-enter"},{"id":"workspace.Pane.SleepBefore","name":"SleepBefore","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"time.Duration","doc":{"summary":"SleepBefore delays before each of this pane's commands. YAML writes it as a number of seconds, matching tmuxp, so 0.5 is half a second."},"source":{"file":"workspace/workspace.go","line":134,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.SleepBefore","product":"workspace","apiScope":"exported","slug":"workspace-pane-sleepbefore"},{"id":"workspace.Pane.SleepAfter","name":"SleepAfter","kind":"attribute","modifiers":[],"parent":"workspace.Pane","signatures":[],"type":"time.Duration","doc":{"summary":"SleepAfter delays after each of this pane's commands, in the same units."},"source":{"file":"workspace/workspace.go","line":136,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.SleepAfter","product":"workspace","apiScope":"exported","slug":"workspace-pane-sleepafter"},{"id":"workspace.Bool","name":"Bool","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Bool accepts YAML booleans and tmuxp's quoted spellings. It is exported so callers can construct optional *Bool fields."},"source":{"file":"workspace/workspace.go","line":141,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Bool","product":"workspace","apiScope":"exported","slug":"workspace-bool"},{"id":"workspace.Bool.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Bool","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes a boolean written as a boolean or as a string."},"source":{"file":"workspace/workspace.go","line":144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Bool.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-bool-unmarshalyaml"},{"id":"workspace.Workspace.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Workspace","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes the workspace, then its shell_command_before, which accepts one command or a list."},"source":{"file":"workspace/workspace.go","line":167,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-workspace-unmarshalyaml"},{"id":"workspace.Window.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Window","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes the window, then its shell_command_before."},"source":{"file":"workspace/workspace.go","line":192,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Window.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-window-unmarshalyaml"},{"id":"workspace.Pane.UnmarshalYAML","name":"UnmarshalYAML","kind":"method","modifiers":[],"parent":"workspace.Pane","signatures":[{"params":[{"name":"node","type":"*yaml.Node"}],"returns":"error"}],"doc":{"summary":"UnmarshalYAML decodes a pane written as a bare command or as a mapping."},"source":{"file":"workspace/workspace.go","line":219,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Pane.UnmarshalYAML","product":"workspace","apiScope":"exported","slug":"workspace-pane-unmarshalyaml"},{"id":"workspace.Parse","name":"Parse","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"document","type":"[]byte"}],"returns":"(Workspace, error)"}],"doc":{"summary":"Parse decodes one workspace document. Unknown fields are rejected so a misspelled key fails loudly instead of being dropped."},"source":{"file":"workspace/workspace.go","line":276,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Parse","product":"workspace","apiScope":"exported","slug":"workspace-parse"},{"id":"workspace.Workspace.Validate","name":"Validate","kind":"method","modifiers":[],"parent":"workspace.Workspace","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Validate reports all problems joined under [ErrInvalidWorkspace]."},"source":{"file":"workspace/workspace.go","line":291,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.Validate","product":"workspace","apiScope":"exported","slug":"workspace-workspace-validate"},{"id":"workspace.Workspace.MissingDirectories","name":"MissingDirectories","kind":"method","modifiers":[],"parent":"workspace.Workspace","signatures":[{"params":[],"returns":"[]string"}],"doc":{"summary":"MissingDirectories returns absent start directories in document order. It is separate from [Workspace.Validate] because a prior command may create them. tmux otherwise falls back to the user's home directory without an error. Names beginning with ~ are resolved as tmux resolves them."},"source":{"file":"workspace/workspace.go","line":407,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"workspace.Workspace.MissingDirectories","product":"workspace","apiScope":"exported","slug":"workspace-workspace-missingdirectories"},{"id":"mcp.AuditEnvironmentVariable","name":"AuditEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"AuditEnvironmentVariable names the variable that turns the record on and says where it goes: \"stderr\", or a path to append to."},"source":{"file":"mcp/audit.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.AuditEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-auditenvironmentvariable"},{"id":"mcp.HandshakeOrdered","name":"HandshakeOrdered","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"inner","type":"mcp.Transport"}],"returns":"mcp.Transport"}],"doc":{"summary":"HandshakeOrdered holds the SDK's early tool-list notification until notifications/initialized; strict legacy clients reject the earlier ordering."},"source":{"file":"mcp/handshake_transport.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.HandshakeOrdered","product":"mcp","apiScope":"exported","slug":"mcp-handshakeordered"},{"id":"mcp.ErrInstanceClosed","name":"ErrInstanceClosed","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrInstanceClosed identifies work refused after instance shutdown starts."},"source":{"file":"mcp/instance.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ErrInstanceClosed","product":"mcp","apiScope":"exported","slug":"mcp-errinstanceclosed"},{"id":"mcp.ErrRequestCapacity","name":"ErrRequestCapacity","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrRequestCapacity identifies a client session closed after it exceeded the server's finite unsettled-call capacity."},"source":{"file":"mcp/instance.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ErrRequestCapacity","product":"mcp","apiScope":"exported","slug":"mcp-errrequestcapacity"},{"id":"mcp.Instance","name":"Instance","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"Instance owns the SDK server, all connected client sessions, and every resource allocated on their behalf. The SDK server is composed so Connect and Run cannot bypass lifecycle tracking."},"source":{"file":"mcp/instance.go","line":30,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.Instance","product":"mcp","apiScope":"exported","slug":"mcp-instance"},{"id":"mcp.ServerSession","name":"ServerSession","kind":"struct","modifiers":[],"signatures":[],"doc":{"summary":"ServerSession owns one SDK session and the resources scoped to its client."},"source":{"file":"mcp/instance.go","line":70,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ServerSession","product":"mcp","apiScope":"exported","slug":"mcp-serversession"},{"id":"mcp.Instance.Connect","name":"Connect","kind":"method","modifiers":[],"parent":"mcp.Instance","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"transport","type":"sdk.Transport"},{"name":"options","type":"*sdk.ServerSessionOptions"}],"returns":"(*ServerSession, error)"}],"doc":{"summary":"Connect starts and tracks one client session. It requires tmux 3.2a or newer and rejects an opaque transport unless [AssumeResponseCommit] marks its response-write contract. Incoming messages remain gated until the SDK session has an installed scope."},"source":{"file":"mcp/instance_connect.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.Instance.Connect","product":"mcp","apiScope":"exported","slug":"mcp-instance-connect"},{"id":"mcp.Instance.Run","name":"Run","kind":"method","modifiers":[],"parent":"mcp.Instance","signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"transport","type":"sdk.Transport"}],"returns":"error"}],"doc":{"summary":"Run serves one tracked session until the client, context, or instance ends. Its transport requirements are the same as [Instance.Connect]."},"source":{"file":"mcp/instance_connect.go","line":102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.Instance.Run","product":"mcp","apiScope":"exported","slug":"mcp-instance-run"},{"id":"mcp.Instance.Close","name":"Close","kind":"method","modifiers":[],"parent":"mcp.Instance","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close starts shutdown and waits on a bounded internal context."},"source":{"file":"mcp/instance_lifecycle.go","line":13,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.Instance.Close","product":"mcp","apiScope":"exported","slug":"mcp-instance-close"},{"id":"mcp.Instance.CloseContext","name":"CloseContext","kind":"method","modifiers":[],"parent":"mcp.Instance","signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"error"}],"doc":{"summary":"CloseContext starts shutdown unconditionally. ctx bounds only this call's wait; a later call can resume waiting for the same shutdown."},"source":{"file":"mcp/instance_lifecycle.go","line":24,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.Instance.CloseContext","product":"mcp","apiScope":"exported","slug":"mcp-instance-closecontext"},{"id":"mcp.ServerSession.Close","name":"Close","kind":"method","modifiers":[],"parent":"mcp.ServerSession","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Close stops scoped work, closes the transport, and joins SDK session cleanup."},"source":{"file":"mcp/instance_lifecycle.go","line":128,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ServerSession.Close","product":"mcp","apiScope":"exported","slug":"mcp-serversession-close"},{"id":"mcp.ServerSession.Wait","name":"Wait","kind":"method","modifiers":[],"parent":"mcp.ServerSession","signatures":[{"params":[],"returns":"error"}],"doc":{"summary":"Wait waits for client termination and session cleanup."},"source":{"file":"mcp/instance_lifecycle.go","line":143,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ServerSession.Wait","product":"mcp","apiScope":"exported","slug":"mcp-serversession-wait"},{"id":"mcp.MaterializeMinimalConfig","name":"MaterializeMinimalConfig","kind":"function","modifiers":[],"signatures":[{"params":[],"returns":"(string, func() error, error)"}],"doc":{"summary":"MaterializeMinimalConfig writes the embedded dedicated-server configuration for tmux's -f option. The caller keeps it until the MCP process stops."},"source":{"file":"mcp/minimal_config.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.MaterializeMinimalConfig","product":"mcp","apiScope":"exported","slug":"mcp-materializeminimalconfig"},{"id":"mcp.CapabilitiesResourceURI","name":"CapabilitiesResourceURI","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"CapabilitiesResourceURI is the only MCP resource exposed by this server."},"source":{"file":"mcp/resources.go","line":11,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.CapabilitiesResourceURI","product":"mcp","apiScope":"exported","slug":"mcp-capabilitiesresourceuri"},{"id":"mcp.ErrResponseCommitUnknown","name":"ErrResponseCommitUnknown","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrResponseCommitUnknown identifies a transport whose successful Write may leave one response buffered behind another response in a JSON-RPC batch."},"source":{"file":"mcp/response_transport.go","line":15,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ErrResponseCommitUnknown","product":"mcp","apiScope":"exported","slug":"mcp-errresponsecommitunknown"},{"id":"mcp.AssumeResponseCommit","name":"AssumeResponseCommit","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"transport","type":"mcp.Transport"}],"returns":"mcp.Transport"}],"doc":{"summary":"AssumeResponseCommit marks transport as committing each response before its Connection.Write returns nil. It does not change transport behavior. Use it only for a transport that rejects JSON-RPC batches or writes every response independently; direct IO and stdio transports are handled automatically."},"source":{"file":"mcp/response_transport.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.AssumeResponseCommit","product":"mcp","apiScope":"exported","slug":"mcp-assumeresponsecommit"},{"id":"mcp.ErrRuntimeTargetBound","name":"ErrRuntimeTargetBound","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"ErrRuntimeTargetBound identifies a target already bound to a terminal Connection. An MCP runtime must own the connection it creates."},"source":{"file":"mcp/runtime.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ErrRuntimeTargetBound","product":"mcp","apiScope":"exported","slug":"mcp-errruntimetargetbound"},{"id":"mcp.Version","name":"Version","kind":"attribute","modifiers":[],"signatures":[],"doc":{"summary":"Version is reported during MCP initialization. Installed binaries derive it from build metadata; source builds use fallbackVersion."},"source":{"file":"mcp/server.go","line":22,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.Version","product":"mcp","apiScope":"exported","slug":"mcp-version"},{"id":"mcp.NewServer","name":"NewServer","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"target","type":"tmux.Server"}],"returns":"(*Instance, error)"}],"doc":{"summary":"NewServer returns a closeable MCP instance exposing target. It rejects an invalid target before allocating instance-owned resources."},"source":{"file":"mcp/server.go","line":144,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.NewServer","product":"mcp","apiScope":"exported","slug":"mcp-newserver"},{"id":"mcp.Run","name":"Run","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"target","type":"tmux.Server"}],"returns":"error"}],"doc":{"summary":"Run serves target over stdin and stdout until ctx is done."},"source":{"file":"mcp/server.go","line":251,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.Run","product":"mcp","apiScope":"exported","slug":"mcp-run"},{"id":"mcp.RunDefaultMinimal","name":"RunDefaultMinimal","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"target","type":"tmux.Server"}],"returns":"error"}],"doc":{"summary":"RunDefaultMinimal serves a package-created default dedicated target. It starts or joins the daemon with a one-use owner marker and grants default teardown only when the marker proves this process created that daemon."},"source":{"file":"mcp/server.go","line":285,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.RunDefaultMinimal","product":"mcp","apiScope":"exported","slug":"mcp-rundefaultminimal"},{"id":"mcp.AdvertisedTools","name":"AdvertisedTools","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"}],"returns":"([]*sdk.Tool, error)"}],"doc":{"summary":"AdvertisedTools returns caller-owned descriptions of the startup-selected tools. It performs an in-memory MCP handshake without opening tmux or allocating runtime-owned audit resources.","body":"It describes a server that creates the default dedicated tmux server, the\nwidest default surface. [AdvertisedToolsFor] answers for a specific target."},"source":{"file":"mcp/tool_catalog.go","line":19,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.AdvertisedTools","product":"mcp","apiScope":"exported","slug":"mcp-advertisedtools"},{"id":"mcp.AdvertisedToolsFor","name":"AdvertisedToolsFor","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"ctx","type":"context.Context"},{"name":"target","type":"tmux.Server"},{"name":"defaultMinimal","type":"bool"}],"returns":"([]*sdk.Tool, error)"}],"doc":{"summary":"AdvertisedToolsFor returns the tools a server started now against target would advertise. defaultMinimal selects [RunDefaultMinimal]'s rule, which grants teardown tools only when that server creates the tmux server, so only when none is answering yet; [Run] never grants them by default. It asks whether a tmux server is answering and starts nothing."},"source":{"file":"mcp/tool_catalog.go","line":36,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.AdvertisedToolsFor","product":"mcp","apiScope":"exported","slug":"mcp-advertisedtoolsfor"},{"id":"mcp.ToolDetails","name":"ToolDetails","kind":"function","modifiers":[],"signatures":[{"params":[{"name":"name","type":"string"}],"returns":"(string, bool)"}],"doc":{"summary":"ToolDetails returns what the named tool does, without the capability disclosure every description opens with. The disclosure is shared across a toolset, so a listing that shows only a description's first sentence would otherwise show the same sentence for every tool in it."},"source":{"file":"mcp/tool_catalog.go","line":102,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ToolDetails","product":"mcp","apiScope":"exported","slug":"mcp-tooldetails"},{"id":"mcp.CapabilityMetaKey","name":"CapabilityMetaKey","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"CapabilityMetaKey is the MCP metadata key carrying the complete capability row that also drives registration and tmux://capabilities."},"source":{"file":"mcp/tool_manifest.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.CapabilityMetaKey","product":"mcp","apiScope":"exported","slug":"mcp-capabilitymetakey"},{"id":"mcp.SocketEnvironmentVariable","name":"SocketEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"SocketEnvironmentVariable selects one named tmux socket."},"source":{"file":"mcp/tool_surface.go","line":12,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.SocketEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-socketenvironmentvariable"},{"id":"mcp.SocketPathEnvironmentVariable","name":"SocketPathEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"SocketPathEnvironmentVariable selects one absolute tmux socket path."},"source":{"file":"mcp/tool_surface.go","line":14,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.SocketPathEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-socketpathenvironmentvariable"},{"id":"mcp.TmuxConfigEnvironmentVariable","name":"TmuxConfigEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"TmuxConfigEnvironmentVariable selects an absolute tmux config path."},"source":{"file":"mcp/tool_surface.go","line":16,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.TmuxConfigEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-tmuxconfigenvironmentvariable"},{"id":"mcp.BinaryEnvironmentVariable","name":"BinaryEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"BinaryEnvironmentVariable selects the tmux executable."},"source":{"file":"mcp/tool_surface.go","line":18,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.BinaryEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-binaryenvironmentvariable"},{"id":"mcp.ToolsetsEnvironmentVariable","name":"ToolsetsEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ToolsetsEnvironmentVariable selects unordered inspect, manage, execute, and teardown groups. A present empty value selects no groups."},"source":{"file":"mcp/tool_surface.go","line":21,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ToolsetsEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-toolsetsenvironmentvariable"},{"id":"mcp.ToolsEnvironmentVariable","name":"ToolsEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ToolsEnvironmentVariable adds exact tool names after toolset expansion."},"source":{"file":"mcp/tool_surface.go","line":23,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ToolsEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-toolsenvironmentvariable"},{"id":"mcp.ExcludeToolsEnvironmentVariable","name":"ExcludeToolsEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"ExcludeToolsEnvironmentVariable removes exact names after every inclusion."},"source":{"file":"mcp/tool_surface.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.ExcludeToolsEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-excludetoolsenvironmentvariable"},{"id":"mcp.SafetyEnvironmentVariable","name":"SafetyEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"SafetyEnvironmentVariable is rejected because ordered safety tiers were retired."},"source":{"file":"mcp/tool_surface.go","line":27,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.SafetyEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-safetyenvironmentvariable"},{"id":"mcp.RecipeToolEnvironmentVariable","name":"RecipeToolEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"RecipeToolEnvironmentVariable is rejected because prompt exports were retired."},"source":{"file":"mcp/tool_surface.go","line":31,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.RecipeToolEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-recipetoolenvironmentvariable"},{"id":"mcp.WaitCeilingEnvironmentVariable","name":"WaitCeilingEnvironmentVariable","kind":"constant","modifiers":[],"signatures":[],"doc":{"summary":"WaitCeilingEnvironmentVariable names the variable that raises or lowers the longest wait this server will run, in seconds. It matches the Python server so an operator configuring both writes one thing."},"source":{"file":"mcp/wait_tools.go","line":25,"repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},"publicId":"mcp.WaitCeilingEnvironmentVariable","product":"mcp","apiScope":"exported","slug":"mcp-waitceilingenvironmentvariable"}],"pruned":{"dropped":92,"kept":2817,"rules":["/^internal\\./","/^tmux\\.internal\\./"]},"sources":[{"product":"core","package":"github.com/libtmux/libtmux-go/tmux","repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},{"product":"workspace","package":"github.com/libtmux/libtmux-go/workspace","repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"},{"product":"mcp","package":"github.com/libtmux/libtmux-go/mcp","repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","extractedRevision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a"}],"repo":"libtmux/libtmux-go"}
diff --git a/site/src/data/api/go.nav.json b/site/src/data/api/go.nav.json
index 98aa0f96..307eacd1 100644
--- a/site/src/data/api/go.nav.json
+++ b/site/src/data/api/go.nav.json
@@ -1 +1 @@
-{"port":"go","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":"tmux.ServerOptionValues","name":"ServerOptionValues","slug":"tmux-serveroptionvalues","kind":"struct"},{"id":"tmux.Server","name":"Server","slug":"tmux-server","kind":"struct"},{"id":"tmux.NewServer","name":"NewServer","slug":"tmux-newserver","kind":"function"},{"id":"tmux.NewServerFromEnv","name":"NewServerFromEnv","slug":"tmux-newserverfromenv","kind":"function"}],"session":[{"id":"tmux.SessionID","name":"SessionID","slug":"tmux-sessionid","kind":"struct"},{"id":"tmux.Session","name":"Session","slug":"tmux-session","kind":"struct"},{"id":"tmux.SessionOptionValues","name":"SessionOptionValues","slug":"tmux-sessionoptionvalues","kind":"struct"},{"id":"tmux.GlobalSessionScope","name":"GlobalSessionScope","slug":"tmux-globalsessionscope","kind":"struct"},{"id":"tmux.SessionFromEnv","name":"SessionFromEnv","slug":"tmux-sessionfromenv","kind":"function"},{"id":"tmux.ValidateSessionName","name":"ValidateSessionName","slug":"tmux-validatesessionname","kind":"function"}],"window":[{"id":"tmux.WindowID","name":"WindowID","slug":"tmux-windowid","kind":"struct"},{"id":"tmux.Window","name":"Window","slug":"tmux-window","kind":"struct"},{"id":"tmux.WindowSize","name":"WindowSize","slug":"tmux-windowsize","kind":"struct"},{"id":"tmux.WindowOptionValues","name":"WindowOptionValues","slug":"tmux-windowoptionvalues","kind":"struct"},{"id":"tmux.GlobalWindowScope","name":"GlobalWindowScope","slug":"tmux-globalwindowscope","kind":"struct"},{"id":"tmux.NewWindowDirection","name":"NewWindowDirection","slug":"tmux-newwindowdirection","kind":"struct"},{"id":"tmux.RotateWindowDirection","name":"RotateWindowDirection","slug":"tmux-rotatewindowdirection","kind":"struct"},{"id":"tmux.WindowResizeDirection","name":"WindowResizeDirection","slug":"tmux-windowresizedirection","kind":"struct"},{"id":"workspace.Window","name":"Window","slug":"workspace-window","kind":"struct"},{"id":"tmux.NewWindowDirectionAfter","name":"NewWindowDirectionAfter","slug":"tmux-newwindowdirectionafter","kind":"constant"},{"id":"tmux.NewWindowDirectionBefore","name":"NewWindowDirectionBefore","slug":"tmux-newwindowdirectionbefore","kind":"constant"},{"id":"tmux.NewWindowDirectionDefault","name":"NewWindowDirectionDefault","slug":"tmux-newwindowdirectiondefault","kind":"constant"},{"id":"tmux.RotateWindowDefault","name":"RotateWindowDefault","slug":"tmux-rotatewindowdefault","kind":"constant"},{"id":"tmux.RotateWindowDown","name":"RotateWindowDown","slug":"tmux-rotatewindowdown","kind":"constant"},{"id":"tmux.RotateWindowUp","name":"RotateWindowUp","slug":"tmux-rotatewindowup","kind":"constant"},{"id":"tmux.WindowResizeDirectionDown","name":"WindowResizeDirectionDown","slug":"tmux-windowresizedirectiondown","kind":"constant"},{"id":"tmux.WindowResizeDirectionLeft","name":"WindowResizeDirectionLeft","slug":"tmux-windowresizedirectionleft","kind":"constant"},{"id":"tmux.WindowResizeDirectionNone","name":"WindowResizeDirectionNone","slug":"tmux-windowresizedirectionnone","kind":"constant"},{"id":"tmux.WindowResizeDirectionRight","name":"WindowResizeDirectionRight","slug":"tmux-windowresizedirectionright","kind":"constant"},{"id":"tmux.WindowResizeDirectionUp","name":"WindowResizeDirectionUp","slug":"tmux-windowresizedirectionup","kind":"constant"},{"id":"tmux.WindowSizeLargest","name":"WindowSizeLargest","slug":"tmux-windowsizelargest","kind":"constant"},{"id":"tmux.WindowSizeLatest","name":"WindowSizeLatest","slug":"tmux-windowsizelatest","kind":"constant"},{"id":"tmux.WindowSizeManual","name":"WindowSizeManual","slug":"tmux-windowsizemanual","kind":"constant"},{"id":"tmux.WindowSizeSmallest","name":"WindowSizeSmallest","slug":"tmux-windowsizesmallest","kind":"constant"},{"id":"tmux.WindowFromEnv","name":"WindowFromEnv","slug":"tmux-windowfromenv","kind":"function"}],"pane":[{"id":"tmux.PaneDirection","name":"PaneDirection","slug":"tmux-panedirection","kind":"struct"},{"id":"tmux.PaneID","name":"PaneID","slug":"tmux-paneid","kind":"struct"},{"id":"tmux.Pane","name":"Pane","slug":"tmux-pane","kind":"struct"},{"id":"tmux.PaneBorderIndicators","name":"PaneBorderIndicators","slug":"tmux-paneborderindicators","kind":"struct"},{"id":"tmux.PaneBorderLines","name":"PaneBorderLines","slug":"tmux-paneborderlines","kind":"struct"},{"id":"tmux.PaneBorderStatus","name":"PaneBorderStatus","slug":"tmux-paneborderstatus","kind":"struct"},{"id":"tmux.PaneScrollbars","name":"PaneScrollbars","slug":"tmux-panescrollbars","kind":"struct"},{"id":"tmux.PaneScrollbarsPosition","name":"PaneScrollbarsPosition","slug":"tmux-panescrollbarsposition","kind":"struct"},{"id":"tmux.PaneOptionValues","name":"PaneOptionValues","slug":"tmux-paneoptionvalues","kind":"struct"},{"id":"tmux.PaneResizeDirection","name":"PaneResizeDirection","slug":"tmux-paneresizedirection","kind":"struct"},{"id":"tmux.PaneSize","name":"PaneSize","slug":"tmux-panesize","kind":"struct"},{"id":"tmux.PaneText","name":"PaneText","slug":"tmux-panetext","kind":"struct"},{"id":"tmux.SwapPaneDirection","name":"SwapPaneDirection","slug":"tmux-swappanedirection","kind":"struct"},{"id":"tmux.PaneSelectDirection","name":"PaneSelectDirection","slug":"tmux-paneselectdirection","kind":"struct"},{"id":"workspace.Pane","name":"Pane","slug":"workspace-pane","kind":"struct"},{"id":"tmux.PaneBorderIndicatorsArrows","name":"PaneBorderIndicatorsArrows","slug":"tmux-paneborderindicatorsarrows","kind":"constant"},{"id":"tmux.PaneBorderIndicatorsBoth","name":"PaneBorderIndicatorsBoth","slug":"tmux-paneborderindicatorsboth","kind":"constant"},{"id":"tmux.PaneBorderIndicatorsColour","name":"PaneBorderIndicatorsColour","slug":"tmux-paneborderindicatorscolour","kind":"constant"},{"id":"tmux.PaneBorderIndicatorsOff","name":"PaneBorderIndicatorsOff","slug":"tmux-paneborderindicatorsoff","kind":"constant"},{"id":"tmux.PaneBorderLinesDouble","name":"PaneBorderLinesDouble","slug":"tmux-paneborderlinesdouble","kind":"constant"},{"id":"tmux.PaneBorderLinesHeavy","name":"PaneBorderLinesHeavy","slug":"tmux-paneborderlinesheavy","kind":"constant"},{"id":"tmux.PaneBorderLinesNumber","name":"PaneBorderLinesNumber","slug":"tmux-paneborderlinesnumber","kind":"constant"},{"id":"tmux.PaneBorderLinesSimple","name":"PaneBorderLinesSimple","slug":"tmux-paneborderlinessimple","kind":"constant"},{"id":"tmux.PaneBorderLinesSingle","name":"PaneBorderLinesSingle","slug":"tmux-paneborderlinessingle","kind":"constant"},{"id":"tmux.PaneBorderLinesSpaces","name":"PaneBorderLinesSpaces","slug":"tmux-paneborderlinesspaces","kind":"constant"},{"id":"tmux.PaneBorderStatusBottom","name":"PaneBorderStatusBottom","slug":"tmux-paneborderstatusbottom","kind":"constant"},{"id":"tmux.PaneBorderStatusOff","name":"PaneBorderStatusOff","slug":"tmux-paneborderstatusoff","kind":"constant"},{"id":"tmux.PaneBorderStatusTop","name":"PaneBorderStatusTop","slug":"tmux-paneborderstatustop","kind":"constant"},{"id":"tmux.PaneDirectionAbove","name":"PaneDirectionAbove","slug":"tmux-panedirectionabove","kind":"constant"},{"id":"tmux.PaneDirectionBelow","name":"PaneDirectionBelow","slug":"tmux-panedirectionbelow","kind":"constant"},{"id":"tmux.PaneDirectionLeft","name":"PaneDirectionLeft","slug":"tmux-panedirectionleft","kind":"constant"},{"id":"tmux.PaneDirectionRight","name":"PaneDirectionRight","slug":"tmux-panedirectionright","kind":"constant"},{"id":"tmux.PaneResizeDirectionDown","name":"PaneResizeDirectionDown","slug":"tmux-paneresizedirectiondown","kind":"constant"},{"id":"tmux.PaneResizeDirectionLeft","name":"PaneResizeDirectionLeft","slug":"tmux-paneresizedirectionleft","kind":"constant"},{"id":"tmux.PaneResizeDirectionNone","name":"PaneResizeDirectionNone","slug":"tmux-paneresizedirectionnone","kind":"constant"},{"id":"tmux.PaneResizeDirectionRight","name":"PaneResizeDirectionRight","slug":"tmux-paneresizedirectionright","kind":"constant"},{"id":"tmux.PaneResizeDirectionUp","name":"PaneResizeDirectionUp","slug":"tmux-paneresizedirectionup","kind":"constant"},{"id":"tmux.PaneScrollbarsModal","name":"PaneScrollbarsModal","slug":"tmux-panescrollbarsmodal","kind":"constant"},{"id":"tmux.PaneScrollbarsOff","name":"PaneScrollbarsOff","slug":"tmux-panescrollbarsoff","kind":"constant"},{"id":"tmux.PaneScrollbarsOn","name":"PaneScrollbarsOn","slug":"tmux-panescrollbarson","kind":"constant"},{"id":"tmux.PaneScrollbarsPositionLeft","name":"PaneScrollbarsPositionLeft","slug":"tmux-panescrollbarspositionleft","kind":"constant"},{"id":"tmux.PaneScrollbarsPositionRight","name":"PaneScrollbarsPositionRight","slug":"tmux-panescrollbarspositionright","kind":"constant"},{"id":"tmux.PaneSelectDirectionDown","name":"PaneSelectDirectionDown","slug":"tmux-paneselectdirectiondown","kind":"constant"},{"id":"tmux.PaneSelectDirectionLast","name":"PaneSelectDirectionLast","slug":"tmux-paneselectdirectionlast","kind":"constant"},{"id":"tmux.PaneSelectDirectionLeft","name":"PaneSelectDirectionLeft","slug":"tmux-paneselectdirectionleft","kind":"constant"},{"id":"tmux.PaneSelectDirectionNone","name":"PaneSelectDirectionNone","slug":"tmux-paneselectdirectionnone","kind":"constant"},{"id":"tmux.PaneSelectDirectionRight","name":"PaneSelectDirectionRight","slug":"tmux-paneselectdirectionright","kind":"constant"},{"id":"tmux.PaneSelectDirectionUp","name":"PaneSelectDirectionUp","slug":"tmux-paneselectdirectionup","kind":"constant"},{"id":"tmux.SwapPaneDirectionDown","name":"SwapPaneDirectionDown","slug":"tmux-swappanedirectiondown","kind":"constant"},{"id":"tmux.SwapPaneDirectionNone","name":"SwapPaneDirectionNone","slug":"tmux-swappanedirectionnone","kind":"constant"},{"id":"tmux.SwapPaneDirectionUp","name":"SwapPaneDirectionUp","slug":"tmux-swappanedirectionup","kind":"constant"},{"id":"tmux.PaneCells","name":"PaneCells","slug":"tmux-panecells","kind":"function"},{"id":"tmux.PaneFromEnv","name":"PaneFromEnv","slug":"tmux-panefromenv","kind":"function"},{"id":"tmux.PanePercent","name":"PanePercent","slug":"tmux-panepercent","kind":"function"}],"client":[{"id":"tmux.ClientAttachment","name":"ClientAttachment","slug":"tmux-clientattachment","kind":"struct"},{"id":"tmux.ClientName","name":"ClientName","slug":"tmux-clientname","kind":"struct"},{"id":"tmux.Client","name":"Client","slug":"tmux-client","kind":"struct"}],"hooks":[{"id":"tmux.ServerHookValues","name":"ServerHookValues","slug":"tmux-serverhookvalues","kind":"struct"},{"id":"tmux.SessionHookValues","name":"SessionHookValues","slug":"tmux-sessionhookvalues","kind":"struct"},{"id":"tmux.WindowHookValues","name":"WindowHookValues","slug":"tmux-windowhookvalues","kind":"struct"},{"id":"tmux.PaneHookValues","name":"PaneHookValues","slug":"tmux-panehookvalues","kind":"struct"}],"options":[{"id":"tmux.AllowPassthrough","name":"AllowPassthrough","slug":"tmux-allowpassthrough","kind":"struct"},{"id":"tmux.CopyModeLineNumbers","name":"CopyModeLineNumbers","slug":"tmux-copymodelinenumbers","kind":"struct"},{"id":"tmux.DestroyUnattached","name":"DestroyUnattached","slug":"tmux-destroyunattached","kind":"struct"},{"id":"tmux.DetachOnDestroy","name":"DetachOnDestroy","slug":"tmux-detachondestroy","kind":"struct"},{"id":"tmux.ExtendedKeys","name":"ExtendedKeys","slug":"tmux-extendedkeys","kind":"struct"},{"id":"tmux.GetClipboard","name":"GetClipboard","slug":"tmux-getclipboard","kind":"struct"},{"id":"tmux.MenuBorderLines","name":"MenuBorderLines","slug":"tmux-menuborderlines","kind":"struct"},{"id":"tmux.MessageLine","name":"MessageLine","slug":"tmux-messageline","kind":"struct"},{"id":"tmux.ModeKeys","name":"ModeKeys","slug":"tmux-modekeys","kind":"struct"},{"id":"tmux.PopupBorderLines","name":"PopupBorderLines","slug":"tmux-popupborderlines","kind":"struct"},{"id":"tmux.RemainOnExit","name":"RemainOnExit","slug":"tmux-remainonexit","kind":"struct"},{"id":"tmux.SetClipboard","name":"SetClipboard","slug":"tmux-setclipboard","kind":"struct"},{"id":"tmux.Status","name":"Status","slug":"tmux-status","kind":"struct"},{"id":"tmux.StatusJustify","name":"StatusJustify","slug":"tmux-statusjustify","kind":"struct"},{"id":"tmux.StatusKeys","name":"StatusKeys","slug":"tmux-statuskeys","kind":"struct"},{"id":"tmux.StatusPosition","name":"StatusPosition","slug":"tmux-statusposition","kind":"struct"},{"id":"tmux.VisualActivity","name":"VisualActivity","slug":"tmux-visualactivity","kind":"struct"},{"id":"tmux.VisualBell","name":"VisualBell","slug":"tmux-visualbell","kind":"struct"},{"id":"tmux.VisualSilence","name":"VisualSilence","slug":"tmux-visualsilence","kind":"struct"},{"id":"tmux.OptionOrigin","name":"OptionOrigin","slug":"tmux-optionorigin","kind":"struct"},{"id":"tmux.OptionValue","name":"OptionValue","slug":"tmux-optionvalue","kind":"struct"},{"id":"tmux.AllowPassthroughAll","name":"AllowPassthroughAll","slug":"tmux-allowpassthroughall","kind":"constant"},{"id":"tmux.AllowPassthroughOff","name":"AllowPassthroughOff","slug":"tmux-allowpassthroughoff","kind":"constant"},{"id":"tmux.AllowPassthroughOn","name":"AllowPassthroughOn","slug":"tmux-allowpassthroughon","kind":"constant"},{"id":"tmux.CopyModeLineNumbersAbsolute","name":"CopyModeLineNumbersAbsolute","slug":"tmux-copymodelinenumbersabsolute","kind":"constant"},{"id":"tmux.CopyModeLineNumbersDefault","name":"CopyModeLineNumbersDefault","slug":"tmux-copymodelinenumbersdefault","kind":"constant"},{"id":"tmux.CopyModeLineNumbersHybrid","name":"CopyModeLineNumbersHybrid","slug":"tmux-copymodelinenumbershybrid","kind":"constant"},{"id":"tmux.CopyModeLineNumbersOff","name":"CopyModeLineNumbersOff","slug":"tmux-copymodelinenumbersoff","kind":"constant"},{"id":"tmux.CopyModeLineNumbersRelative","name":"CopyModeLineNumbersRelative","slug":"tmux-copymodelinenumbersrelative","kind":"constant"},{"id":"tmux.DestroyUnattachedKeepGroup","name":"DestroyUnattachedKeepGroup","slug":"tmux-destroyunattachedkeepgroup","kind":"constant"},{"id":"tmux.DestroyUnattachedKeepLast","name":"DestroyUnattachedKeepLast","slug":"tmux-destroyunattachedkeeplast","kind":"constant"},{"id":"tmux.DestroyUnattachedOff","name":"DestroyUnattachedOff","slug":"tmux-destroyunattachedoff","kind":"constant"},{"id":"tmux.DestroyUnattachedOn","name":"DestroyUnattachedOn","slug":"tmux-destroyunattachedon","kind":"constant"},{"id":"tmux.DetachOnDestroyNext","name":"DetachOnDestroyNext","slug":"tmux-detachondestroynext","kind":"constant"},{"id":"tmux.DetachOnDestroyNoDetached","name":"DetachOnDestroyNoDetached","slug":"tmux-detachondestroynodetached","kind":"constant"},{"id":"tmux.DetachOnDestroyOff","name":"DetachOnDestroyOff","slug":"tmux-detachondestroyoff","kind":"constant"},{"id":"tmux.DetachOnDestroyOn","name":"DetachOnDestroyOn","slug":"tmux-detachondestroyon","kind":"constant"},{"id":"tmux.DetachOnDestroyPrevious","name":"DetachOnDestroyPrevious","slug":"tmux-detachondestroyprevious","kind":"constant"},{"id":"tmux.ExtendedKeysAlways","name":"ExtendedKeysAlways","slug":"tmux-extendedkeysalways","kind":"constant"},{"id":"tmux.ExtendedKeysOff","name":"ExtendedKeysOff","slug":"tmux-extendedkeysoff","kind":"constant"},{"id":"tmux.ExtendedKeysOn","name":"ExtendedKeysOn","slug":"tmux-extendedkeyson","kind":"constant"},{"id":"tmux.GetClipboardBoth","name":"GetClipboardBoth","slug":"tmux-getclipboardboth","kind":"constant"},{"id":"tmux.GetClipboardBuffer","name":"GetClipboardBuffer","slug":"tmux-getclipboardbuffer","kind":"constant"},{"id":"tmux.GetClipboardOff","name":"GetClipboardOff","slug":"tmux-getclipboardoff","kind":"constant"},{"id":"tmux.GetClipboardRequest","name":"GetClipboardRequest","slug":"tmux-getclipboardrequest","kind":"constant"},{"id":"tmux.MenuBorderLinesDouble","name":"MenuBorderLinesDouble","slug":"tmux-menuborderlinesdouble","kind":"constant"},{"id":"tmux.MenuBorderLinesHeavy","name":"MenuBorderLinesHeavy","slug":"tmux-menuborderlinesheavy","kind":"constant"},{"id":"tmux.MenuBorderLinesNone","name":"MenuBorderLinesNone","slug":"tmux-menuborderlinesnone","kind":"constant"},{"id":"tmux.MenuBorderLinesPadded","name":"MenuBorderLinesPadded","slug":"tmux-menuborderlinespadded","kind":"constant"},{"id":"tmux.MenuBorderLinesRounded","name":"MenuBorderLinesRounded","slug":"tmux-menuborderlinesrounded","kind":"constant"},{"id":"tmux.MenuBorderLinesSimple","name":"MenuBorderLinesSimple","slug":"tmux-menuborderlinessimple","kind":"constant"},{"id":"tmux.MenuBorderLinesSingle","name":"MenuBorderLinesSingle","slug":"tmux-menuborderlinessingle","kind":"constant"},{"id":"tmux.MessageLine0","name":"MessageLine0","slug":"tmux-messageline0","kind":"constant"},{"id":"tmux.MessageLine1","name":"MessageLine1","slug":"tmux-messageline1","kind":"constant"},{"id":"tmux.MessageLine2","name":"MessageLine2","slug":"tmux-messageline2","kind":"constant"},{"id":"tmux.MessageLine3","name":"MessageLine3","slug":"tmux-messageline3","kind":"constant"},{"id":"tmux.MessageLine4","name":"MessageLine4","slug":"tmux-messageline4","kind":"constant"},{"id":"tmux.ModeKeysEmacs","name":"ModeKeysEmacs","slug":"tmux-modekeysemacs","kind":"constant"},{"id":"tmux.ModeKeysVi","name":"ModeKeysVi","slug":"tmux-modekeysvi","kind":"constant"},{"id":"tmux.OptionOriginInherited","name":"OptionOriginInherited","slug":"tmux-optionorigininherited","kind":"constant"},{"id":"tmux.OptionOriginLocal","name":"OptionOriginLocal","slug":"tmux-optionoriginlocal","kind":"constant"},{"id":"tmux.PopupBorderLinesDouble","name":"PopupBorderLinesDouble","slug":"tmux-popupborderlinesdouble","kind":"constant"},{"id":"tmux.PopupBorderLinesHeavy","name":"PopupBorderLinesHeavy","slug":"tmux-popupborderlinesheavy","kind":"constant"},{"id":"tmux.PopupBorderLinesNone","name":"PopupBorderLinesNone","slug":"tmux-popupborderlinesnone","kind":"constant"},{"id":"tmux.PopupBorderLinesPadded","name":"PopupBorderLinesPadded","slug":"tmux-popupborderlinespadded","kind":"constant"},{"id":"tmux.PopupBorderLinesRounded","name":"PopupBorderLinesRounded","slug":"tmux-popupborderlinesrounded","kind":"constant"},{"id":"tmux.PopupBorderLinesSimple","name":"PopupBorderLinesSimple","slug":"tmux-popupborderlinessimple","kind":"constant"},{"id":"tmux.PopupBorderLinesSingle","name":"PopupBorderLinesSingle","slug":"tmux-popupborderlinessingle","kind":"constant"},{"id":"tmux.RemainOnExitFailed","name":"RemainOnExitFailed","slug":"tmux-remainonexitfailed","kind":"constant"},{"id":"tmux.RemainOnExitKey","name":"RemainOnExitKey","slug":"tmux-remainonexitkey","kind":"constant"},{"id":"tmux.RemainOnExitOff","name":"RemainOnExitOff","slug":"tmux-remainonexitoff","kind":"constant"},{"id":"tmux.RemainOnExitOn","name":"RemainOnExitOn","slug":"tmux-remainonexiton","kind":"constant"},{"id":"tmux.SetClipboardExternal","name":"SetClipboardExternal","slug":"tmux-setclipboardexternal","kind":"constant"},{"id":"tmux.SetClipboardOff","name":"SetClipboardOff","slug":"tmux-setclipboardoff","kind":"constant"},{"id":"tmux.SetClipboardOn","name":"SetClipboardOn","slug":"tmux-setclipboardon","kind":"constant"},{"id":"tmux.Status2","name":"Status2","slug":"tmux-status2","kind":"constant"},{"id":"tmux.Status3","name":"Status3","slug":"tmux-status3","kind":"constant"},{"id":"tmux.Status4","name":"Status4","slug":"tmux-status4","kind":"constant"},{"id":"tmux.Status5","name":"Status5","slug":"tmux-status5","kind":"constant"},{"id":"tmux.StatusJustifyAbsoluteCentre","name":"StatusJustifyAbsoluteCentre","slug":"tmux-statusjustifyabsolutecentre","kind":"constant"},{"id":"tmux.StatusJustifyCentre","name":"StatusJustifyCentre","slug":"tmux-statusjustifycentre","kind":"constant"},{"id":"tmux.StatusJustifyLeft","name":"StatusJustifyLeft","slug":"tmux-statusjustifyleft","kind":"constant"},{"id":"tmux.StatusJustifyRight","name":"StatusJustifyRight","slug":"tmux-statusjustifyright","kind":"constant"},{"id":"tmux.StatusKeysEmacs","name":"StatusKeysEmacs","slug":"tmux-statuskeysemacs","kind":"constant"},{"id":"tmux.StatusKeysVi","name":"StatusKeysVi","slug":"tmux-statuskeysvi","kind":"constant"},{"id":"tmux.StatusOff","name":"StatusOff","slug":"tmux-statusoff","kind":"constant"},{"id":"tmux.StatusOn","name":"StatusOn","slug":"tmux-statuson","kind":"constant"},{"id":"tmux.StatusPositionBottom","name":"StatusPositionBottom","slug":"tmux-statuspositionbottom","kind":"constant"},{"id":"tmux.StatusPositionTop","name":"StatusPositionTop","slug":"tmux-statuspositiontop","kind":"constant"},{"id":"tmux.VisualActivityBoth","name":"VisualActivityBoth","slug":"tmux-visualactivityboth","kind":"constant"},{"id":"tmux.VisualActivityOff","name":"VisualActivityOff","slug":"tmux-visualactivityoff","kind":"constant"},{"id":"tmux.VisualActivityOn","name":"VisualActivityOn","slug":"tmux-visualactivityon","kind":"constant"},{"id":"tmux.VisualBellBoth","name":"VisualBellBoth","slug":"tmux-visualbellboth","kind":"constant"},{"id":"tmux.VisualBellOff","name":"VisualBellOff","slug":"tmux-visualbelloff","kind":"constant"},{"id":"tmux.VisualBellOn","name":"VisualBellOn","slug":"tmux-visualbellon","kind":"constant"},{"id":"tmux.VisualSilenceBoth","name":"VisualSilenceBoth","slug":"tmux-visualsilenceboth","kind":"constant"},{"id":"tmux.VisualSilenceOff","name":"VisualSilenceOff","slug":"tmux-visualsilenceoff","kind":"constant"},{"id":"tmux.VisualSilenceOn","name":"VisualSilenceOn","slug":"tmux-visualsilenceon","kind":"constant"}],"options-functions":[],"options-constants":[],"keys":[{"id":"tmux.PrefixKey","name":"PrefixKey","slug":"tmux-prefixkey","kind":"struct"},{"id":"tmux.PrefixPrimary","name":"PrefixPrimary","slug":"tmux-prefixprimary","kind":"constant"},{"id":"tmux.PrefixSecondary","name":"PrefixSecondary","slug":"tmux-prefixsecondary","kind":"constant"}],"buffers":[],"layout":[],"environment":[{"id":"tmux.EnvironmentValue","name":"EnvironmentValue","slug":"tmux-environmentvalue","kind":"struct"}],"capabilities":[{"id":"tmux.TerminalFeature","name":"TerminalFeature","slug":"tmux-terminalfeature","kind":"struct"},{"id":"tmux.TerminalFeatures","name":"TerminalFeatures","slug":"tmux-terminalfeatures","kind":"struct"},{"id":"tmux.TerminalOverrideValue","name":"TerminalOverrideValue","slug":"tmux-terminaloverridevalue","kind":"struct"},{"id":"tmux.TerminalCapability","name":"TerminalCapability","slug":"tmux-terminalcapability","kind":"struct"},{"id":"tmux.TerminalOverride","name":"TerminalOverride","slug":"tmux-terminaloverride","kind":"struct"},{"id":"tmux.TerminalOverrideEntry","name":"TerminalOverrideEntry","slug":"tmux-terminaloverrideentry","kind":"struct"},{"id":"tmux.TerminalOverrides","name":"TerminalOverrides","slug":"tmux-terminaloverrides","kind":"struct"}],"version":[{"id":"tmux.Version","name":"Version","slug":"tmux-version","kind":"struct"},{"id":"tmux.MinimumConnectionVersion","name":"MinimumConnectionVersion","slug":"tmux-minimumconnectionversion","kind":"constant"},{"id":"tmux.MinimumSupportedVersion","name":"MinimumSupportedVersion","slug":"tmux-minimumsupportedversion","kind":"constant"},{"id":"tmux.ModulePath","name":"ModulePath","slug":"tmux-modulepath","kind":"constant"},{"id":"tmux.PackageVersion","name":"PackageVersion","slug":"tmux-packageversion","kind":"function"},{"id":"tmux.ParseVersion","name":"ParseVersion","slug":"tmux-parseversion","kind":"function"}],"commands":[{"id":"tmux.CommandAlias","name":"CommandAlias","slug":"tmux-commandalias","kind":"struct"},{"id":"tmux.CommandAliases","name":"CommandAliases","slug":"tmux-commandaliases","kind":"struct"},{"id":"tmux.Connection","name":"Connection","slug":"tmux-connection","kind":"struct"},{"id":"tmux.CommandTransport","name":"CommandTransport","slug":"tmux-commandtransport","kind":"struct"},{"id":"tmux.CommandTrace","name":"CommandTrace","slug":"tmux-commandtrace","kind":"struct"},{"id":"tmux.CommandObserver","name":"CommandObserver","slug":"tmux-commandobserver","kind":"struct"},{"id":"tmux.Running","name":"Running","slug":"tmux-running","kind":"struct"},{"id":"workspace.Command","name":"Command","slug":"workspace-command","kind":"struct"},{"id":"tmux.CommandTransportConnection","name":"CommandTransportConnection","slug":"tmux-commandtransportconnection","kind":"constant"},{"id":"tmux.CommandTransportProcess","name":"CommandTransportProcess","slug":"tmux-commandtransportprocess","kind":"constant"}],"control":[{"id":"tmux.ControlClient","name":"ControlClient","slug":"tmux-controlclient","kind":"struct"},{"id":"tmux.ControlNotification","name":"ControlNotification","slug":"tmux-controlnotification","kind":"struct"},{"id":"tmux.SubscriptionChange","name":"SubscriptionChange","slug":"tmux-subscriptionchange","kind":"struct"},{"id":"tmux.PaneObservation","name":"PaneObservation","slug":"tmux-paneobservation","kind":"struct"},{"id":"tmux.NotificationStream","name":"NotificationStream","slug":"tmux-notificationstream","kind":"struct"},{"id":"tmux.ParseControlNotification","name":"ParseControlNotification","slug":"tmux-parsecontrolnotification","kind":"function"}],"formats":[{"id":"tmux.FormatValues","name":"FormatValues","slug":"tmux-formatvalues","kind":"struct"},{"id":"tmux.ExtendedKeysFormat","name":"ExtendedKeysFormat","slug":"tmux-extendedkeysformat","kind":"struct"},{"id":"tmux.ExtendedKeysFormatCSIU","name":"ExtendedKeysFormatCSIU","slug":"tmux-extendedkeysformatcsiu","kind":"constant"},{"id":"tmux.ExtendedKeysFormatXTerm","name":"ExtendedKeysFormatXTerm","slug":"tmux-extendedkeysformatxterm","kind":"constant"}],"queries":[{"id":"tmux.SessionFilter","name":"SessionFilter","slug":"tmux-sessionfilter","kind":"struct"},{"id":"tmux.WindowFilter","name":"WindowFilter","slug":"tmux-windowfilter","kind":"struct"},{"id":"tmux.PaneFilter","name":"PaneFilter","slug":"tmux-panefilter","kind":"struct"},{"id":"tmux.ClientFilter","name":"ClientFilter","slug":"tmux-clientfilter","kind":"struct"},{"id":"tmux.WindowRel","name":"WindowRel","slug":"tmux-windowrel","kind":"struct"},{"id":"tmux.PaneRel","name":"PaneRel","slug":"tmux-panerel","kind":"struct"},{"id":"tmux.TmuxFilter","name":"TmuxFilter","slug":"tmux-tmuxfilter","kind":"struct"},{"id":"tmuxq.Filter","name":"Filter","slug":"tmuxq-filter","kind":"struct"},{"id":"tmux.FilterSchemaVersion","name":"FilterSchemaVersion","slug":"tmux-filterschemaversion","kind":"constant"},{"id":"tmux.ClientNameIs","name":"ClientNameIs","slug":"tmux-clientnameis","kind":"function"},{"id":"tmux.ClientReadOnlyIs","name":"ClientReadOnlyIs","slug":"tmux-clientreadonlyis","kind":"function"},{"id":"tmuxq.ExactlyOne","name":"ExactlyOne","slug":"tmuxq-exactlyone","kind":"function"},{"id":"tmuxq.ExactlyOneSeq","name":"ExactlyOneSeq","slug":"tmuxq-exactlyoneseq","kind":"function"},{"id":"tmuxq.First","name":"First","slug":"tmuxq-first","kind":"function"},{"id":"tmuxq.FirstSeq","name":"FirstSeq","slug":"tmuxq-firstseq","kind":"function"},{"id":"tmuxq.Matching","name":"Matching","slug":"tmuxq-matching","kind":"function"},{"id":"tmuxq.MatchingSeq","name":"MatchingSeq","slug":"tmuxq-matchingseq","kind":"function"},{"id":"tmux.PaneActiveIs","name":"PaneActiveIs","slug":"tmux-paneactiveis","kind":"function"},{"id":"tmux.PaneCommandIs","name":"PaneCommandIs","slug":"tmux-panecommandis","kind":"function"},{"id":"tmux.PaneIDIs","name":"PaneIDIs","slug":"tmux-paneidis","kind":"function"},{"id":"tmux.PaneIndexIs","name":"PaneIndexIs","slug":"tmux-paneindexis","kind":"function"},{"id":"tmux.PaneSessionIDIs","name":"PaneSessionIDIs","slug":"tmux-panesessionidis","kind":"function"},{"id":"tmux.PaneTitleIs","name":"PaneTitleIs","slug":"tmux-panetitleis","kind":"function"},{"id":"tmux.PaneWindowIDIs","name":"PaneWindowIDIs","slug":"tmux-panewindowidis","kind":"function"},{"id":"tmux.PaneWindowIndexIs","name":"PaneWindowIndexIs","slug":"tmux-panewindowindexis","kind":"function"},{"id":"tmux.ParseClientLookup","name":"ParseClientLookup","slug":"tmux-parseclientlookup","kind":"function"},{"id":"tmux.ParsePaneLookup","name":"ParsePaneLookup","slug":"tmux-parsepanelookup","kind":"function"},{"id":"tmux.ParseSessionLookup","name":"ParseSessionLookup","slug":"tmux-parsesessionlookup","kind":"function"},{"id":"tmux.ParseWindowLookup","name":"ParseWindowLookup","slug":"tmux-parsewindowlookup","kind":"function"},{"id":"tmux.Ptr","name":"Ptr","slug":"tmux-ptr","kind":"function"},{"id":"tmux.SessionAttachedIs","name":"SessionAttachedIs","slug":"tmux-sessionattachedis","kind":"function"},{"id":"tmux.SessionIDIs","name":"SessionIDIs","slug":"tmux-sessionidis","kind":"function"},{"id":"tmux.SessionNameIs","name":"SessionNameIs","slug":"tmux-sessionnameis","kind":"function"},{"id":"tmuxq.Where","name":"Where","slug":"tmuxq-where","kind":"function"},{"id":"tmuxq.WhereSeq","name":"WhereSeq","slug":"tmuxq-whereseq","kind":"function"},{"id":"tmux.WindowActiveIs","name":"WindowActiveIs","slug":"tmux-windowactiveis","kind":"function"},{"id":"tmux.WindowIDIs","name":"WindowIDIs","slug":"tmux-windowidis","kind":"function"},{"id":"tmux.WindowIndexIs","name":"WindowIndexIs","slug":"tmux-windowindexis","kind":"function"},{"id":"tmux.WindowNameIs","name":"WindowNameIs","slug":"tmux-windownameis","kind":"function"},{"id":"tmux.WindowSessionIDIs","name":"WindowSessionIDIs","slug":"tmux-windowsessionidis","kind":"function"}],"queries-fields":[],"queries-operators":[],"queries-expressions":[],"snapshots":[{"id":"tmux.CapturePosition","name":"CapturePosition","slug":"tmux-captureposition","kind":"struct"},{"id":"tmux.Snapshot","name":"Snapshot","slug":"tmux-snapshot","kind":"struct"},{"id":"tmux.CaptureBoundary","name":"CaptureBoundary","slug":"tmux-captureboundary","kind":"constant"},{"id":"tmux.CaptureLine","name":"CaptureLine","slug":"tmux-captureline","kind":"function"}],"workspace":[{"id":"tmux.Ref","name":"Ref","slug":"tmux-ref","kind":"struct"},{"id":"tmux.Op","name":"Op","slug":"tmux-op","kind":"struct"},{"id":"tmux.Dispatch","name":"Dispatch","slug":"tmux-dispatch","kind":"struct"},{"id":"tmux.Sequential","name":"Sequential","slug":"tmux-sequential","kind":"struct"},{"id":"tmux.Folding","name":"Folding","slug":"tmux-folding","kind":"struct"},{"id":"tmux.OpStatus","name":"OpStatus","slug":"tmux-opstatus","kind":"struct"},{"id":"tmux.OpComplete","name":"OpComplete","slug":"tmux-opcomplete","kind":"constant"},{"id":"tmux.OpFailed","name":"OpFailed","slug":"tmux-opfailed","kind":"constant"},{"id":"tmux.OpIndeterminate","name":"OpIndeterminate","slug":"tmux-opindeterminate","kind":"constant"},{"id":"tmux.OpSkipped","name":"OpSkipped","slug":"tmux-opskipped","kind":"constant"}],"workspace-plan":[{"id":"tmux.Plan","name":"Plan","slug":"tmux-plan","kind":"struct"},{"id":"tmux.Planner","name":"Planner","slug":"tmux-planner","kind":"struct"},{"id":"workspace.Workspace","name":"Workspace","slug":"workspace-workspace","kind":"struct"},{"id":"tmux.NewPlan","name":"NewPlan","slug":"tmux-newplan","kind":"function"}],"workspace-steps":[],"workspace-targets":[],"workspace-session":[{"id":"tmux.SessionRef","name":"SessionRef","slug":"tmux-sessionref","kind":"function"}],"workspace-window":[{"id":"tmux.WindowRef","name":"WindowRef","slug":"tmux-windowref","kind":"function"}],"workspace-pane":[{"id":"tmux.PaneRef","name":"PaneRef","slug":"tmux-paneref","kind":"function"}],"workspace-functions":[{"id":"workspace.Build","name":"Build","slug":"workspace-build","kind":"function"},{"id":"workspace.BuildInto","name":"BuildInto","slug":"workspace-buildinto","kind":"function"},{"id":"workspace.Parse","name":"Parse","slug":"workspace-parse","kind":"function"}],"workspace-constants":[],"requests":[{"id":"tmux.DisplayMessageRequest","name":"DisplayMessageRequest","slug":"tmux-displaymessagerequest","kind":"struct"},{"id":"tmux.SubscriptionRequest","name":"SubscriptionRequest","slug":"tmux-subscriptionrequest","kind":"struct"},{"id":"tmux.SendKeysRequest","name":"SendKeysRequest","slug":"tmux-sendkeysrequest","kind":"struct"},{"id":"tmux.SendKeySequenceRequest","name":"SendKeySequenceRequest","slug":"tmux-sendkeysequencerequest","kind":"struct"},{"id":"tmux.ClearHistoryRequest","name":"ClearHistoryRequest","slug":"tmux-clearhistoryrequest","kind":"struct"},{"id":"tmux.CopyModeRequest","name":"CopyModeRequest","slug":"tmux-copymoderequest","kind":"struct"},{"id":"tmux.ChooseTreeRequest","name":"ChooseTreeRequest","slug":"tmux-choosetreerequest","kind":"struct"},{"id":"tmux.DisplayPopupRequest","name":"DisplayPopupRequest","slug":"tmux-displaypopuprequest","kind":"struct"},{"id":"tmux.PasteBufferRequest","name":"PasteBufferRequest","slug":"tmux-pastebufferrequest","kind":"struct"},{"id":"tmux.SetPlanOptionRequest","name":"SetPlanOptionRequest","slug":"tmux-setplanoptionrequest","kind":"struct"},{"id":"tmux.PromptHistoryRequest","name":"PromptHistoryRequest","slug":"tmux-prompthistoryrequest","kind":"struct"},{"id":"tmux.SetBufferRequest","name":"SetBufferRequest","slug":"tmux-setbufferrequest","kind":"struct"},{"id":"tmux.SaveBufferRequest","name":"SaveBufferRequest","slug":"tmux-savebufferrequest","kind":"struct"},{"id":"tmux.LoadBufferRequest","name":"LoadBufferRequest","slug":"tmux-loadbufferrequest","kind":"struct"},{"id":"tmux.ListBuffersRequest","name":"ListBuffersRequest","slug":"tmux-listbuffersrequest","kind":"struct"},{"id":"tmux.RunShellRequest","name":"RunShellRequest","slug":"tmux-runshellrequest","kind":"struct"},{"id":"tmux.WaitForRequest","name":"WaitForRequest","slug":"tmux-waitforrequest","kind":"struct"},{"id":"tmux.IfShellRequest","name":"IfShellRequest","slug":"tmux-ifshellrequest","kind":"struct"},{"id":"tmux.SourceFileRequest","name":"SourceFileRequest","slug":"tmux-sourcefilerequest","kind":"struct"},{"id":"tmux.ConfirmBeforeRequest","name":"ConfirmBeforeRequest","slug":"tmux-confirmbeforerequest","kind":"struct"},{"id":"tmux.CommandPromptRequest","name":"CommandPromptRequest","slug":"tmux-commandpromptrequest","kind":"struct"},{"id":"tmux.DisplayMenuRequest","name":"DisplayMenuRequest","slug":"tmux-displaymenurequest","kind":"struct"},{"id":"tmux.BindKeyRequest","name":"BindKeyRequest","slug":"tmux-bindkeyrequest","kind":"struct"},{"id":"tmux.UnbindKeyRequest","name":"UnbindKeyRequest","slug":"tmux-unbindkeyrequest","kind":"struct"},{"id":"tmux.ListKeysRequest","name":"ListKeysRequest","slug":"tmux-listkeysrequest","kind":"struct"},{"id":"tmux.ListCommandsRequest","name":"ListCommandsRequest","slug":"tmux-listcommandsrequest","kind":"struct"},{"id":"tmux.ShowMessagesRequest","name":"ShowMessagesRequest","slug":"tmux-showmessagesrequest","kind":"struct"},{"id":"tmux.SelectLayoutRequest","name":"SelectLayoutRequest","slug":"tmux-selectlayoutrequest","kind":"struct"},{"id":"tmux.RespawnRequest","name":"RespawnRequest","slug":"tmux-respawnrequest","kind":"struct"},{"id":"tmux.ErrInvalidCaptureRequest","name":"ErrInvalidCaptureRequest","slug":"tmux-errinvalidcapturerequest","kind":"attribute"},{"id":"tmux.ErrInvalidRequest","name":"ErrInvalidRequest","slug":"tmux-errinvalidrequest","kind":"attribute"}],"requests-server":[{"id":"tmux.ServerAccessRequest","name":"ServerAccessRequest","slug":"tmux-serveraccessrequest","kind":"struct"},{"id":"tmux.ErrInvalidServerCommandRequest","name":"ErrInvalidServerCommandRequest","slug":"tmux-errinvalidservercommandrequest","kind":"attribute"}],"requests-session":[{"id":"tmux.SessionKillRequest","name":"SessionKillRequest","slug":"tmux-sessionkillrequest","kind":"struct"},{"id":"tmux.AttachSessionRequest","name":"AttachSessionRequest","slug":"tmux-attachsessionrequest","kind":"struct"},{"id":"tmux.HasSessionRequest","name":"HasSessionRequest","slug":"tmux-hassessionrequest","kind":"struct"},{"id":"tmux.NewSessionRequest","name":"NewSessionRequest","slug":"tmux-newsessionrequest","kind":"struct"}],"requests-window":[{"id":"tmux.KillWindowRequest","name":"KillWindowRequest","slug":"tmux-killwindowrequest","kind":"struct"},{"id":"tmux.FindWindowRequest","name":"FindWindowRequest","slug":"tmux-findwindowrequest","kind":"struct"},{"id":"tmux.SelectWindowRequest","name":"SelectWindowRequest","slug":"tmux-selectwindowrequest","kind":"struct"},{"id":"tmux.NewWindowRequest","name":"NewWindowRequest","slug":"tmux-newwindowrequest","kind":"struct"},{"id":"tmux.LinkWindowRequest","name":"LinkWindowRequest","slug":"tmux-linkwindowrequest","kind":"struct"},{"id":"tmux.UnlinkWindowRequest","name":"UnlinkWindowRequest","slug":"tmux-unlinkwindowrequest","kind":"struct"},{"id":"tmux.MoveWindowRequest","name":"MoveWindowRequest","slug":"tmux-movewindowrequest","kind":"struct"},{"id":"tmux.SwapWindowRequest","name":"SwapWindowRequest","slug":"tmux-swapwindowrequest","kind":"struct"},{"id":"tmux.WindowSelectPaneRequest","name":"WindowSelectPaneRequest","slug":"tmux-windowselectpanerequest","kind":"struct"},{"id":"tmux.RotateWindowRequest","name":"RotateWindowRequest","slug":"tmux-rotatewindowrequest","kind":"struct"},{"id":"tmux.ResizeWindowRequest","name":"ResizeWindowRequest","slug":"tmux-resizewindowrequest","kind":"struct"}],"requests-pane":[{"id":"tmux.PaneDisplayMessageRequest","name":"PaneDisplayMessageRequest","slug":"tmux-panedisplaymessagerequest","kind":"struct"},{"id":"tmux.CapturePaneRequest","name":"CapturePaneRequest","slug":"tmux-capturepanerequest","kind":"struct"},{"id":"tmux.NewPaneRequest","name":"NewPaneRequest","slug":"tmux-newpanerequest","kind":"struct"},{"id":"tmux.SplitPaneRequest","name":"SplitPaneRequest","slug":"tmux-splitpanerequest","kind":"struct"},{"id":"tmux.ResizePaneRequest","name":"ResizePaneRequest","slug":"tmux-resizepanerequest","kind":"struct"},{"id":"tmux.DisplayPanesRequest","name":"DisplayPanesRequest","slug":"tmux-displaypanesrequest","kind":"struct"},{"id":"tmux.PipePaneRequest","name":"PipePaneRequest","slug":"tmux-pipepanerequest","kind":"struct"},{"id":"tmux.MovePaneRequest","name":"MovePaneRequest","slug":"tmux-movepanerequest","kind":"struct"},{"id":"tmux.JoinPaneRequest","name":"JoinPaneRequest","slug":"tmux-joinpanerequest","kind":"struct"},{"id":"tmux.BreakPaneRequest","name":"BreakPaneRequest","slug":"tmux-breakpanerequest","kind":"struct"},{"id":"tmux.SwapPaneRequest","name":"SwapPaneRequest","slug":"tmux-swappanerequest","kind":"struct"},{"id":"tmux.PaneSelectRequest","name":"PaneSelectRequest","slug":"tmux-paneselectrequest","kind":"struct"},{"id":"tmux.LastPaneRequest","name":"LastPaneRequest","slug":"tmux-lastpanerequest","kind":"struct"}],"requests-client":[{"id":"tmux.RefreshClientRequest","name":"RefreshClientRequest","slug":"tmux-refreshclientrequest","kind":"struct"},{"id":"tmux.DetachClientRequest","name":"DetachClientRequest","slug":"tmux-detachclientrequest","kind":"struct"},{"id":"tmux.DetachAllClientsRequest","name":"DetachAllClientsRequest","slug":"tmux-detachallclientsrequest","kind":"struct"}],"errors":[{"id":"tmux.ColorError","name":"ColorError","slug":"tmux-colorerror","kind":"struct"},{"id":"tmux.CommandError","name":"CommandError","slug":"tmux-commanderror","kind":"struct"},{"id":"tmux.ComplexOptionDecodeError","name":"ComplexOptionDecodeError","slug":"tmux-complexoptiondecodeerror","kind":"struct"},{"id":"tmux.ControlNotificationError","name":"ControlNotificationError","slug":"tmux-controlnotificationerror","kind":"struct"},{"id":"tmux.ControlNotificationOverflowError","name":"ControlNotificationOverflowError","slug":"tmux-controlnotificationoverflowerror","kind":"struct"},{"id":"tmux.ControlProtocolError","name":"ControlProtocolError","slug":"tmux-controlprotocolerror","kind":"struct"},{"id":"tmux.EnvironmentNameError","name":"EnvironmentNameError","slug":"tmux-environmentnameerror","kind":"struct"},{"id":"tmux.EnvironmentValueError","name":"EnvironmentValueError","slug":"tmux-environmentvalueerror","kind":"struct"},{"id":"tmux.EnvironmentDecodeError","name":"EnvironmentDecodeError","slug":"tmux-environmentdecodeerror","kind":"struct"},{"id":"tmux.FormatDecodeError","name":"FormatDecodeError","slug":"tmux-formatdecodeerror","kind":"struct"},{"id":"tmux.FromEnvError","name":"FromEnvError","slug":"tmux-fromenverror","kind":"struct"},{"id":"tmux.OptionDecodeError","name":"OptionDecodeError","slug":"tmux-optiondecodeerror","kind":"struct"},{"id":"tmux.OptionValueError","name":"OptionValueError","slug":"tmux-optionvalueerror","kind":"struct"},{"id":"tmux.OptionError","name":"OptionError","slug":"tmux-optionerror","kind":"struct"},{"id":"tmux.CaptureRequestError","name":"CaptureRequestError","slug":"tmux-capturerequesterror","kind":"struct"},{"id":"tmux.PlanError","name":"PlanError","slug":"tmux-planerror","kind":"struct"},{"id":"tmux.VersionQueryError","name":"VersionQueryError","slug":"tmux-versionqueryerror","kind":"struct"},{"id":"tmux.VersionTooLowError","name":"VersionTooLowError","slug":"tmux-versiontoolowerror","kind":"struct"},{"id":"tmux.SnapshotDecodeError","name":"SnapshotDecodeError","slug":"tmux-snapshotdecodeerror","kind":"struct"},{"id":"tmux.SnapshotLookupError","name":"SnapshotLookupError","slug":"tmux-snapshotlookuperror","kind":"struct"},{"id":"tmux.TargetError","name":"TargetError","slug":"tmux-targeterror","kind":"struct"},{"id":"tmux.MissingTargetError","name":"MissingTargetError","slug":"tmux-missingtargeterror","kind":"struct"},{"id":"tmux.VersionError","name":"VersionError","slug":"tmux-versionerror","kind":"struct"},{"id":"tmux.ErrAmbiguousOption","name":"ErrAmbiguousOption","slug":"tmux-errambiguousoption","kind":"attribute"},{"id":"tmux.ErrCommand","name":"ErrCommand","slug":"tmux-errcommand","kind":"attribute"},{"id":"tmux.ErrConnectionRequiresProcess","name":"ErrConnectionRequiresProcess","slug":"tmux-errconnectionrequiresprocess","kind":"attribute"},{"id":"tmux.ErrControlClosed","name":"ErrControlClosed","slug":"tmux-errcontrolclosed","kind":"attribute"},{"id":"tmux.ErrControlNotificationOverflow","name":"ErrControlNotificationOverflow","slug":"tmux-errcontrolnotificationoverflow","kind":"attribute"},{"id":"tmux.ErrControlProtocol","name":"ErrControlProtocol","slug":"tmux-errcontrolprotocol","kind":"attribute"},{"id":"tmux.ErrControlReplyCount","name":"ErrControlReplyCount","slug":"tmux-errcontrolreplycount","kind":"attribute"},{"id":"tmux.ErrControlStreamLost","name":"ErrControlStreamLost","slug":"tmux-errcontrolstreamlost","kind":"attribute"},{"id":"tmux.ErrDaemonReplaced","name":"ErrDaemonReplaced","slug":"tmux-errdaemonreplaced","kind":"attribute"},{"id":"tmux.ErrDuplicateSparseIndex","name":"ErrDuplicateSparseIndex","slug":"tmux-errduplicatesparseindex","kind":"attribute"},{"id":"tmux.ErrInvalidCommandOutput","name":"ErrInvalidCommandOutput","slug":"tmux-errinvalidcommandoutput","kind":"attribute"},{"id":"tmux.ErrInvalidEnvironmentName","name":"ErrInvalidEnvironmentName","slug":"tmux-errinvalidenvironmentname","kind":"attribute"},{"id":"tmux.ErrInvalidEnvironmentValue","name":"ErrInvalidEnvironmentValue","slug":"tmux-errinvalidenvironmentvalue","kind":"attribute"},{"id":"tmux.ErrInvalidFilter","name":"ErrInvalidFilter","slug":"tmux-errinvalidfilter","kind":"attribute"},{"id":"tmux.ErrInvalidOption","name":"ErrInvalidOption","slug":"tmux-errinvalidoption","kind":"attribute"},{"id":"tmux.ErrInvalidOptionValue","name":"ErrInvalidOptionValue","slug":"tmux-errinvalidoptionvalue","kind":"attribute"},{"id":"tmux.ErrInvalidSparseIndex","name":"ErrInvalidSparseIndex","slug":"tmux-errinvalidsparseindex","kind":"attribute"},{"id":"tmux.ErrInvalidTarget","name":"ErrInvalidTarget","slug":"tmux-errinvalidtarget","kind":"attribute"},{"id":"tmux.ErrInvalidVersion","name":"ErrInvalidVersion","slug":"tmux-errinvalidversion","kind":"attribute"},{"id":"workspace.ErrInvalidWorkspace","name":"ErrInvalidWorkspace","slug":"workspace-errinvalidworkspace","kind":"attribute"},{"id":"tmux.ErrMalformedComplexOption","name":"ErrMalformedComplexOption","slug":"tmux-errmalformedcomplexoption","kind":"attribute"},{"id":"tmux.ErrMalformedControlNotification","name":"ErrMalformedControlNotification","slug":"tmux-errmalformedcontrolnotification","kind":"attribute"},{"id":"tmux.ErrMalformedEnvironment","name":"ErrMalformedEnvironment","slug":"tmux-errmalformedenvironment","kind":"attribute"},{"id":"tmux.ErrMalformedFormatOutput","name":"ErrMalformedFormatOutput","slug":"tmux-errmalformedformatoutput","kind":"attribute"},{"id":"tmux.ErrMalformedOptionOutput","name":"ErrMalformedOptionOutput","slug":"tmux-errmalformedoptionoutput","kind":"attribute"},{"id":"tmux.ErrMalformedSnapshot","name":"ErrMalformedSnapshot","slug":"tmux-errmalformedsnapshot","kind":"attribute"},{"id":"tmux.ErrMissingSubcommand","name":"ErrMissingSubcommand","slug":"tmux-errmissingsubcommand","kind":"attribute"},{"id":"tmux.ErrMissingTarget","name":"ErrMissingTarget","slug":"tmux-errmissingtarget","kind":"attribute"},{"id":"tmuxq.ErrMultipleMatches","name":"ErrMultipleMatches","slug":"tmuxq-errmultiplematches","kind":"attribute"},{"id":"tmuxq.ErrNoMatch","name":"ErrNoMatch","slug":"tmuxq-errnomatch","kind":"attribute"},{"id":"tmux.ErrNotFound","name":"ErrNotFound","slug":"tmux-errnotfound","kind":"attribute"},{"id":"tmux.ErrNotInsideTmux","name":"ErrNotInsideTmux","slug":"tmux-errnotinsidetmux","kind":"attribute"},{"id":"tmux.ErrOption","name":"ErrOption","slug":"tmux-erroption","kind":"attribute"},{"id":"tmux.ErrOptionTarget","name":"ErrOptionTarget","slug":"tmux-erroptiontarget","kind":"attribute"},{"id":"tmux.ErrOutcomeUnknown","name":"ErrOutcomeUnknown","slug":"tmux-erroutcomeunknown","kind":"attribute"},{"id":"tmux.ErrOutcomeUnrecorded","name":"ErrOutcomeUnrecorded","slug":"tmux-erroutcomeunrecorded","kind":"attribute"},{"id":"tmux.ErrPlan","name":"ErrPlan","slug":"tmux-errplan","kind":"attribute"},{"id":"tmux.ErrPollCondition","name":"ErrPollCondition","slug":"tmux-errpollcondition","kind":"attribute"},{"id":"tmux.ErrSnapshotAmbiguous","name":"ErrSnapshotAmbiguous","slug":"tmux-errsnapshotambiguous","kind":"attribute"},{"id":"tmux.ErrUnknownColor","name":"ErrUnknownColor","slug":"tmux-errunknowncolor","kind":"attribute"},{"id":"tmux.ErrUnknownControlNotification","name":"ErrUnknownControlNotification","slug":"tmux-errunknowncontrolnotification","kind":"attribute"},{"id":"tmux.ErrUnknownOption","name":"ErrUnknownOption","slug":"tmux-errunknownoption","kind":"attribute"},{"id":"tmux.ErrVersionQuery","name":"ErrVersionQuery","slug":"tmux-errversionquery","kind":"attribute"},{"id":"tmux.ErrVersionTooLow","name":"ErrVersionTooLow","slug":"tmux-errversiontoolow","kind":"attribute"}],"errors-server":[{"id":"tmux.ServerCommandRequestError","name":"ServerCommandRequestError","slug":"tmux-servercommandrequesterror","kind":"struct"},{"id":"tmux.ErrInvalidServer","name":"ErrInvalidServer","slug":"tmux-errinvalidserver","kind":"attribute"},{"id":"tmux.ErrInvalidServerOptions","name":"ErrInvalidServerOptions","slug":"tmux-errinvalidserveroptions","kind":"attribute"},{"id":"tmux.ErrNoServer","name":"ErrNoServer","slug":"tmux-errnoserver","kind":"attribute"}],"errors-session":[{"id":"tmux.ErrSessionExists","name":"ErrSessionExists","slug":"tmux-errsessionexists","kind":"attribute"}],"errors-window":[],"errors-pane":[{"id":"tmux.ErrPaneObservationLost","name":"ErrPaneObservationLost","slug":"tmux-errpaneobservationlost","kind":"attribute"}],"constants":[{"id":"tmux.ColorMode","name":"ColorMode","slug":"tmux-colormode","kind":"struct"},{"id":"tmux.CommandResult","name":"CommandResult","slug":"tmux-commandresult","kind":"struct"},{"id":"tmux.TerminalOverrideValueKind","name":"TerminalOverrideValueKind","slug":"tmux-terminaloverridevaluekind","kind":"struct"},{"id":"tmux.ConnectionOptions","name":"ConnectionOptions","slug":"tmux-connectionoptions","kind":"struct"},{"id":"tmux.ControlCommandResult","name":"ControlCommandResult","slug":"tmux-controlcommandresult","kind":"struct"},{"id":"tmux.SetEnvironmentOptions","name":"SetEnvironmentOptions","slug":"tmux-setenvironmentoptions","kind":"struct"},{"id":"tmux.SetHooksOptions","name":"SetHooksOptions","slug":"tmux-sethooksoptions","kind":"struct"},{"id":"tmux.SetHooksResult","name":"SetHooksResult","slug":"tmux-sethooksresult","kind":"struct"},{"id":"tmux.NotificationOptions","name":"NotificationOptions","slug":"tmux-notificationoptions","kind":"struct"},{"id":"tmux.ActivityAction","name":"ActivityAction","slug":"tmux-activityaction","kind":"struct"},{"id":"tmux.BellAction","name":"BellAction","slug":"tmux-bellaction","kind":"struct"},{"id":"tmux.ClockModeStyle","name":"ClockModeStyle","slug":"tmux-clockmodestyle","kind":"struct"},{"id":"tmux.CursorStyle","name":"CursorStyle","slug":"tmux-cursorstyle","kind":"struct"},{"id":"tmux.PromptCommandCursorStyle","name":"PromptCommandCursorStyle","slug":"tmux-promptcommandcursorstyle","kind":"struct"},{"id":"tmux.PromptCursorStyle","name":"PromptCursorStyle","slug":"tmux-promptcursorstyle","kind":"struct"},{"id":"tmux.SilenceAction","name":"SilenceAction","slug":"tmux-silenceaction","kind":"struct"},{"id":"tmux.ControlNotificationKind","name":"ControlNotificationKind","slug":"tmux-controlnotificationkind","kind":"struct"},{"id":"tmux.SetOptionOptions","name":"SetOptionOptions","slug":"tmux-setoptionoptions","kind":"struct"},{"id":"tmux.UnsetOptionOptions","name":"UnsetOptionOptions","slug":"tmux-unsetoptionoptions","kind":"struct"},{"id":"tmux.SetArrayResult","name":"SetArrayResult","slug":"tmux-setarrayresult","kind":"struct"},{"id":"tmux.PlanResult","name":"PlanResult","slug":"tmux-planresult","kind":"struct"},{"id":"tmux.OpResult","name":"OpResult","slug":"tmux-opresult","kind":"struct"},{"id":"tmux.LoadBufferFromOptions","name":"LoadBufferFromOptions","slug":"tmux-loadbufferfromoptions","kind":"struct"},{"id":"tmux.SaveBufferToOptions","name":"SaveBufferToOptions","slug":"tmux-savebuffertooptions","kind":"struct"},{"id":"tmux.WaitForMode","name":"WaitForMode","slug":"tmux-waitformode","kind":"struct"},{"id":"tmux.RunOptions","name":"RunOptions","slug":"tmux-runoptions","kind":"struct"},{"id":"tmux.RunResult","name":"RunResult","slug":"tmux-runresult","kind":"struct"},{"id":"tmux.WarningKind","name":"WarningKind","slug":"tmux-warningkind","kind":"struct"},{"id":"tmux.ActivityActionAny","name":"ActivityActionAny","slug":"tmux-activityactionany","kind":"constant"},{"id":"tmux.ActivityActionCurrent","name":"ActivityActionCurrent","slug":"tmux-activityactioncurrent","kind":"constant"},{"id":"tmux.ActivityActionNone","name":"ActivityActionNone","slug":"tmux-activityactionnone","kind":"constant"},{"id":"tmux.ActivityActionOther","name":"ActivityActionOther","slug":"tmux-activityactionother","kind":"constant"},{"id":"tmux.BellActionAny","name":"BellActionAny","slug":"tmux-bellactionany","kind":"constant"},{"id":"tmux.BellActionCurrent","name":"BellActionCurrent","slug":"tmux-bellactioncurrent","kind":"constant"},{"id":"tmux.BellActionNone","name":"BellActionNone","slug":"tmux-bellactionnone","kind":"constant"},{"id":"tmux.BellActionOther","name":"BellActionOther","slug":"tmux-bellactionother","kind":"constant"},{"id":"tmux.ClockModeStyle12","name":"ClockModeStyle12","slug":"tmux-clockmodestyle12","kind":"constant"},{"id":"tmux.ClockModeStyle12WithSeconds","name":"ClockModeStyle12WithSeconds","slug":"tmux-clockmodestyle12withseconds","kind":"constant"},{"id":"tmux.ClockModeStyle24","name":"ClockModeStyle24","slug":"tmux-clockmodestyle24","kind":"constant"},{"id":"tmux.ClockModeStyle24WithSeconds","name":"ClockModeStyle24WithSeconds","slug":"tmux-clockmodestyle24withseconds","kind":"constant"},{"id":"tmux.Color256","name":"Color256","slug":"tmux-color256","kind":"constant"},{"id":"tmux.Color88","name":"Color88","slug":"tmux-color88","kind":"constant"},{"id":"tmux.ColorDefault","name":"ColorDefault","slug":"tmux-colordefault","kind":"constant"},{"id":"tmux.ControlNotificationClientDetached","name":"ControlNotificationClientDetached","slug":"tmux-controlnotificationclientdetached","kind":"constant"},{"id":"tmux.ControlNotificationClientSessionChanged","name":"ControlNotificationClientSessionChanged","slug":"tmux-controlnotificationclientsessionchanged","kind":"constant"},{"id":"tmux.ControlNotificationConfigError","name":"ControlNotificationConfigError","slug":"tmux-controlnotificationconfigerror","kind":"constant"},{"id":"tmux.ControlNotificationContinue","name":"ControlNotificationContinue","slug":"tmux-controlnotificationcontinue","kind":"constant"},{"id":"tmux.ControlNotificationExit","name":"ControlNotificationExit","slug":"tmux-controlnotificationexit","kind":"constant"},{"id":"tmux.ControlNotificationExtendedOutput","name":"ControlNotificationExtendedOutput","slug":"tmux-controlnotificationextendedoutput","kind":"constant"},{"id":"tmux.ControlNotificationLayoutChange","name":"ControlNotificationLayoutChange","slug":"tmux-controlnotificationlayoutchange","kind":"constant"},{"id":"tmux.ControlNotificationMessage","name":"ControlNotificationMessage","slug":"tmux-controlnotificationmessage","kind":"constant"},{"id":"tmux.ControlNotificationOutput","name":"ControlNotificationOutput","slug":"tmux-controlnotificationoutput","kind":"constant"},{"id":"tmux.ControlNotificationPaneModeChanged","name":"ControlNotificationPaneModeChanged","slug":"tmux-controlnotificationpanemodechanged","kind":"constant"},{"id":"tmux.ControlNotificationPasteBufferChanged","name":"ControlNotificationPasteBufferChanged","slug":"tmux-controlnotificationpastebufferchanged","kind":"constant"},{"id":"tmux.ControlNotificationPasteBufferDeleted","name":"ControlNotificationPasteBufferDeleted","slug":"tmux-controlnotificationpastebufferdeleted","kind":"constant"},{"id":"tmux.ControlNotificationPause","name":"ControlNotificationPause","slug":"tmux-controlnotificationpause","kind":"constant"},{"id":"tmux.ControlNotificationSessionChanged","name":"ControlNotificationSessionChanged","slug":"tmux-controlnotificationsessionchanged","kind":"constant"},{"id":"tmux.ControlNotificationSessionRenamed","name":"ControlNotificationSessionRenamed","slug":"tmux-controlnotificationsessionrenamed","kind":"constant"},{"id":"tmux.ControlNotificationSessionsChanged","name":"ControlNotificationSessionsChanged","slug":"tmux-controlnotificationsessionschanged","kind":"constant"},{"id":"tmux.ControlNotificationSessionWindowChanged","name":"ControlNotificationSessionWindowChanged","slug":"tmux-controlnotificationsessionwindowchanged","kind":"constant"},{"id":"tmux.ControlNotificationSubscriptionChanged","name":"ControlNotificationSubscriptionChanged","slug":"tmux-controlnotificationsubscriptionchanged","kind":"constant"},{"id":"tmux.ControlNotificationUnlinkedWindowAdd","name":"ControlNotificationUnlinkedWindowAdd","slug":"tmux-controlnotificationunlinkedwindowadd","kind":"constant"},{"id":"tmux.ControlNotificationUnlinkedWindowClose","name":"ControlNotificationUnlinkedWindowClose","slug":"tmux-controlnotificationunlinkedwindowclose","kind":"constant"},{"id":"tmux.ControlNotificationUnlinkedWindowRenamed","name":"ControlNotificationUnlinkedWindowRenamed","slug":"tmux-controlnotificationunlinkedwindowrenamed","kind":"constant"},{"id":"tmux.ControlNotificationWindowAdd","name":"ControlNotificationWindowAdd","slug":"tmux-controlnotificationwindowadd","kind":"constant"},{"id":"tmux.ControlNotificationWindowClose","name":"ControlNotificationWindowClose","slug":"tmux-controlnotificationwindowclose","kind":"constant"},{"id":"tmux.ControlNotificationWindowPaneChanged","name":"ControlNotificationWindowPaneChanged","slug":"tmux-controlnotificationwindowpanechanged","kind":"constant"},{"id":"tmux.ControlNotificationWindowRenamed","name":"ControlNotificationWindowRenamed","slug":"tmux-controlnotificationwindowrenamed","kind":"constant"},{"id":"tmux.CursorStyleBar","name":"CursorStyleBar","slug":"tmux-cursorstylebar","kind":"constant"},{"id":"tmux.CursorStyleBlinkingBar","name":"CursorStyleBlinkingBar","slug":"tmux-cursorstyleblinkingbar","kind":"constant"},{"id":"tmux.CursorStyleBlinkingBlock","name":"CursorStyleBlinkingBlock","slug":"tmux-cursorstyleblinkingblock","kind":"constant"},{"id":"tmux.CursorStyleBlinkingUnderline","name":"CursorStyleBlinkingUnderline","slug":"tmux-cursorstyleblinkingunderline","kind":"constant"},{"id":"tmux.CursorStyleBlock","name":"CursorStyleBlock","slug":"tmux-cursorstyleblock","kind":"constant"},{"id":"tmux.CursorStyleDefault","name":"CursorStyleDefault","slug":"tmux-cursorstyledefault","kind":"constant"},{"id":"tmux.CursorStyleUnderline","name":"CursorStyleUnderline","slug":"tmux-cursorstyleunderline","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBar","name":"PromptCommandCursorStyleBar","slug":"tmux-promptcommandcursorstylebar","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBlinkingBar","name":"PromptCommandCursorStyleBlinkingBar","slug":"tmux-promptcommandcursorstyleblinkingbar","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBlinkingBlock","name":"PromptCommandCursorStyleBlinkingBlock","slug":"tmux-promptcommandcursorstyleblinkingblock","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBlinkingUnderline","name":"PromptCommandCursorStyleBlinkingUnderline","slug":"tmux-promptcommandcursorstyleblinkingunderline","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBlock","name":"PromptCommandCursorStyleBlock","slug":"tmux-promptcommandcursorstyleblock","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleDefault","name":"PromptCommandCursorStyleDefault","slug":"tmux-promptcommandcursorstyledefault","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleUnderline","name":"PromptCommandCursorStyleUnderline","slug":"tmux-promptcommandcursorstyleunderline","kind":"constant"},{"id":"tmux.PromptCursorStyleBar","name":"PromptCursorStyleBar","slug":"tmux-promptcursorstylebar","kind":"constant"},{"id":"tmux.PromptCursorStyleBlinkingBar","name":"PromptCursorStyleBlinkingBar","slug":"tmux-promptcursorstyleblinkingbar","kind":"constant"},{"id":"tmux.PromptCursorStyleBlinkingBlock","name":"PromptCursorStyleBlinkingBlock","slug":"tmux-promptcursorstyleblinkingblock","kind":"constant"},{"id":"tmux.PromptCursorStyleBlinkingUnderline","name":"PromptCursorStyleBlinkingUnderline","slug":"tmux-promptcursorstyleblinkingunderline","kind":"constant"},{"id":"tmux.PromptCursorStyleBlock","name":"PromptCursorStyleBlock","slug":"tmux-promptcursorstyleblock","kind":"constant"},{"id":"tmux.PromptCursorStyleDefault","name":"PromptCursorStyleDefault","slug":"tmux-promptcursorstyledefault","kind":"constant"},{"id":"tmux.PromptCursorStyleUnderline","name":"PromptCursorStyleUnderline","slug":"tmux-promptcursorstyleunderline","kind":"constant"},{"id":"tmux.SilenceActionAny","name":"SilenceActionAny","slug":"tmux-silenceactionany","kind":"constant"},{"id":"tmux.SilenceActionCurrent","name":"SilenceActionCurrent","slug":"tmux-silenceactioncurrent","kind":"constant"},{"id":"tmux.SilenceActionNone","name":"SilenceActionNone","slug":"tmux-silenceactionnone","kind":"constant"},{"id":"tmux.SilenceActionOther","name":"SilenceActionOther","slug":"tmux-silenceactionother","kind":"constant"},{"id":"tmux.TerminalOverrideValueFlag","name":"TerminalOverrideValueFlag","slug":"tmux-terminaloverridevalueflag","kind":"constant"},{"id":"tmux.TerminalOverrideValueInteger","name":"TerminalOverrideValueInteger","slug":"tmux-terminaloverridevalueinteger","kind":"constant"},{"id":"tmux.TerminalOverrideValueText","name":"TerminalOverrideValueText","slug":"tmux-terminaloverridevaluetext","kind":"constant"},{"id":"tmux.WaitForModeLock","name":"WaitForModeLock","slug":"tmux-waitformodelock","kind":"constant"},{"id":"tmux.WaitForModeSignal","name":"WaitForModeSignal","slug":"tmux-waitformodesignal","kind":"constant"},{"id":"tmux.WaitForModeUnlock","name":"WaitForModeUnlock","slug":"tmux-waitformodeunlock","kind":"constant"},{"id":"tmux.WaitForModeWait","name":"WaitForModeWait","slug":"tmux-waitformodewait","kind":"constant"},{"id":"tmux.WarningCommandStderr","name":"WarningCommandStderr","slug":"tmux-warningcommandstderr","kind":"constant"},{"id":"tmux.WarningUnsupportedFeature","name":"WarningUnsupportedFeature","slug":"tmux-warningunsupportedfeature","kind":"constant"}],"constants-server":[{"id":"tmux.ServerOptions","name":"ServerOptions","slug":"tmux-serveroptions","kind":"struct"}],"constants-session":[{"id":"tmux.AttachSessionOptions","name":"AttachSessionOptions","slug":"tmux-attachsessionoptions","kind":"struct"}],"constants-window":[{"id":"tmux.WindowSwapResult","name":"WindowSwapResult","slug":"tmux-windowswapresult","kind":"struct"}],"constants-pane":[{"id":"tmux.PaneSwapResult","name":"PaneSwapResult","slug":"tmux-paneswapresult","kind":"struct"},{"id":"tmux.PaneMarkMode","name":"PaneMarkMode","slug":"tmux-panemarkmode","kind":"struct"},{"id":"tmux.PaneInputMode","name":"PaneInputMode","slug":"tmux-paneinputmode","kind":"struct"},{"id":"tmux.PaneInputDisable","name":"PaneInputDisable","slug":"tmux-paneinputdisable","kind":"constant"},{"id":"tmux.PaneInputEnable","name":"PaneInputEnable","slug":"tmux-paneinputenable","kind":"constant"},{"id":"tmux.PaneInputUnchanged","name":"PaneInputUnchanged","slug":"tmux-paneinputunchanged","kind":"constant"},{"id":"tmux.PaneMarkClear","name":"PaneMarkClear","slug":"tmux-panemarkclear","kind":"constant"},{"id":"tmux.PaneMarkSet","name":"PaneMarkSet","slug":"tmux-panemarkset","kind":"constant"},{"id":"tmux.PaneMarkUnchanged","name":"PaneMarkUnchanged","slug":"tmux-panemarkunchanged","kind":"constant"}],"constants-client":[],"runtime":[],"async":[],"mcp":[{"id":"mcp.Instance","name":"Instance","slug":"mcp-instance","kind":"struct"},{"id":"mcp.ServerSession","name":"ServerSession","slug":"mcp-serversession","kind":"struct"}],"mcp-functions":[{"id":"mcp.AdvertisedTools","name":"AdvertisedTools","slug":"mcp-advertisedtools","kind":"function"},{"id":"mcp.AdvertisedToolsFor","name":"AdvertisedToolsFor","slug":"mcp-advertisedtoolsfor","kind":"function"},{"id":"mcp.AssumeResponseCommit","name":"AssumeResponseCommit","slug":"mcp-assumeresponsecommit","kind":"function"},{"id":"mcp.HandshakeOrdered","name":"HandshakeOrdered","slug":"mcp-handshakeordered","kind":"function"},{"id":"mcp.MaterializeMinimalConfig","name":"MaterializeMinimalConfig","slug":"mcp-materializeminimalconfig","kind":"function"},{"id":"mcp.NewServer","name":"NewServer","slug":"mcp-newserver","kind":"function"},{"id":"mcp.Run","name":"Run","slug":"mcp-run","kind":"function"},{"id":"mcp.RunDefaultMinimal","name":"RunDefaultMinimal","slug":"mcp-rundefaultminimal","kind":"function"},{"id":"mcp.ToolDetails","name":"ToolDetails","slug":"mcp-tooldetails","kind":"function"}],"mcp-constants":[{"id":"mcp.AuditEnvironmentVariable","name":"AuditEnvironmentVariable","slug":"mcp-auditenvironmentvariable","kind":"constant"},{"id":"mcp.BinaryEnvironmentVariable","name":"BinaryEnvironmentVariable","slug":"mcp-binaryenvironmentvariable","kind":"constant"},{"id":"mcp.CapabilitiesResourceURI","name":"CapabilitiesResourceURI","slug":"mcp-capabilitiesresourceuri","kind":"constant"},{"id":"mcp.CapabilityMetaKey","name":"CapabilityMetaKey","slug":"mcp-capabilitymetakey","kind":"constant"},{"id":"mcp.ErrInstanceClosed","name":"ErrInstanceClosed","slug":"mcp-errinstanceclosed","kind":"attribute"},{"id":"mcp.ErrRequestCapacity","name":"ErrRequestCapacity","slug":"mcp-errrequestcapacity","kind":"attribute"},{"id":"mcp.ErrResponseCommitUnknown","name":"ErrResponseCommitUnknown","slug":"mcp-errresponsecommitunknown","kind":"attribute"},{"id":"mcp.ErrRuntimeTargetBound","name":"ErrRuntimeTargetBound","slug":"mcp-errruntimetargetbound","kind":"attribute"},{"id":"mcp.ExcludeToolsEnvironmentVariable","name":"ExcludeToolsEnvironmentVariable","slug":"mcp-excludetoolsenvironmentvariable","kind":"constant"},{"id":"mcp.RecipeToolEnvironmentVariable","name":"RecipeToolEnvironmentVariable","slug":"mcp-recipetoolenvironmentvariable","kind":"constant"},{"id":"mcp.SafetyEnvironmentVariable","name":"SafetyEnvironmentVariable","slug":"mcp-safetyenvironmentvariable","kind":"constant"},{"id":"mcp.SocketEnvironmentVariable","name":"SocketEnvironmentVariable","slug":"mcp-socketenvironmentvariable","kind":"constant"},{"id":"mcp.SocketPathEnvironmentVariable","name":"SocketPathEnvironmentVariable","slug":"mcp-socketpathenvironmentvariable","kind":"constant"},{"id":"mcp.TmuxConfigEnvironmentVariable","name":"TmuxConfigEnvironmentVariable","slug":"mcp-tmuxconfigenvironmentvariable","kind":"constant"},{"id":"mcp.ToolsEnvironmentVariable","name":"ToolsEnvironmentVariable","slug":"mcp-toolsenvironmentvariable","kind":"constant"},{"id":"mcp.ToolsetsEnvironmentVariable","name":"ToolsetsEnvironmentVariable","slug":"mcp-toolsetsenvironmentvariable","kind":"constant"},{"id":"mcp.Version","name":"Version","slug":"mcp-version","kind":"attribute"},{"id":"mcp.WaitCeilingEnvironmentVariable","name":"WaitCeilingEnvironmentVariable","slug":"mcp-waitceilingenvironmentvariable","kind":"constant"}],"testing":[{"id":"tmuxtest.ControlMode","name":"ControlMode","slug":"tmuxtest-controlmode","kind":"struct"},{"id":"tmuxtest.ServerOptions","name":"ServerOptions","slug":"tmuxtest-serveroptions","kind":"struct"},{"id":"tmuxtest.PTYProcess","name":"PTYProcess","slug":"tmuxtest-ptyprocess","kind":"struct"},{"id":"tmuxtest.ScriptedCommand","name":"ScriptedCommand","slug":"tmuxtest-scriptedcommand","kind":"struct"},{"id":"tmux.MaximumTestedVersion","name":"MaximumTestedVersion","slug":"tmux-maximumtestedversion","kind":"constant"},{"id":"tmuxtest.ShellPrompt","name":"ShellPrompt","slug":"tmuxtest-shellprompt","kind":"constant"},{"id":"tmuxtest.SuiteRootTagVariable","name":"SuiteRootTagVariable","slug":"tmuxtest-suiteroottagvariable","kind":"constant"},{"id":"tmuxtest.TemporaryNamePrefix","name":"TemporaryNamePrefix","slug":"tmuxtest-temporarynameprefix","kind":"constant"},{"id":"tmuxtest.Main","name":"Main","slug":"tmuxtest-main","kind":"function"},{"id":"tmuxtest.NewControlMode","name":"NewControlMode","slug":"tmuxtest-newcontrolmode","kind":"function"},{"id":"tmuxtest.NewServer","name":"NewServer","slug":"tmuxtest-newserver","kind":"function"},{"id":"tmuxtest.NewServerWithOptions","name":"NewServerWithOptions","slug":"tmuxtest-newserverwithoptions","kind":"function"},{"id":"tmuxtest.NewSession","name":"NewSession","slug":"tmuxtest-newsession","kind":"function"},{"id":"tmuxtest.NewWindow","name":"NewWindow","slug":"tmuxtest-newwindow","kind":"function"},{"id":"tmuxtest.RunInPane","name":"RunInPane","slug":"tmuxtest-runinpane","kind":"function"},{"id":"tmuxtest.Screen","name":"Screen","slug":"tmuxtest-screen","kind":"function"},{"id":"tmuxtest.ScriptedTmux","name":"ScriptedTmux","slug":"tmuxtest-scriptedtmux","kind":"function"},{"id":"tmuxtest.StartPTYProcess","name":"StartPTYProcess","slug":"tmuxtest-startptyprocess","kind":"function"},{"id":"tmuxtest.Type","name":"Type","slug":"tmuxtest-type","kind":"function"},{"id":"tmuxtest.TypeAndWait","name":"TypeAndWait","slug":"tmuxtest-typeandwait","kind":"function"},{"id":"tmuxtest.WaitFor","name":"WaitFor","slug":"tmuxtest-waitfor","kind":"function"},{"id":"tmuxtest.WaitForLine","name":"WaitForLine","slug":"tmuxtest-waitforline","kind":"function"},{"id":"tmuxtest.WaitForScreen","name":"WaitForScreen","slug":"tmuxtest-waitforscreen","kind":"function"},{"id":"tmuxtest.WaitForShellReady","name":"WaitForShellReady","slug":"tmuxtest-waitforshellready","kind":"function"},{"id":"tmuxtest.WaitForText","name":"WaitForText","slug":"tmuxtest-waitfortext","kind":"function"}],"internal":[],"internal-commands":[],"internal-options":[]},"placement":{"tmux.NewServerFromEnv":"server","tmux.ServerOptionValues":"server","tmux.Server":"server","tmux.NewServer":"server","tmux.SessionFromEnv":"session","tmux.SessionID":"session","tmux.Session":"session","tmux.SessionOptionValues":"session","tmux.GlobalSessionScope":"session","tmux.ValidateSessionName":"session","tmux.WindowFromEnv":"window","tmux.WindowID":"window","tmux.Window":"window","tmux.WindowSize":"window","tmux.WindowOptionValues":"window","tmux.GlobalWindowScope":"window","tmux.NewWindowDirection":"window","tmux.RotateWindowDirection":"window","tmux.WindowResizeDirection":"window","workspace.Window":"window","tmux.WindowSizeLargest":"window","tmux.WindowSizeSmallest":"window","tmux.WindowSizeManual":"window","tmux.WindowSizeLatest":"window","tmux.NewWindowDirectionDefault":"window","tmux.NewWindowDirectionAfter":"window","tmux.NewWindowDirectionBefore":"window","tmux.RotateWindowDefault":"window","tmux.RotateWindowUp":"window","tmux.RotateWindowDown":"window","tmux.WindowResizeDirectionNone":"window","tmux.WindowResizeDirectionUp":"window","tmux.WindowResizeDirectionDown":"window","tmux.WindowResizeDirectionLeft":"window","tmux.WindowResizeDirectionRight":"window","tmux.PaneFromEnv":"pane","tmux.PaneDirection":"pane","tmux.PaneID":"pane","tmux.Pane":"pane","tmux.PaneBorderIndicators":"pane","tmux.PaneBorderLines":"pane","tmux.PaneBorderStatus":"pane","tmux.PaneScrollbars":"pane","tmux.PaneScrollbarsPosition":"pane","tmux.PaneOptionValues":"pane","tmux.PaneResizeDirection":"pane","tmux.PaneSize":"pane","tmux.PaneCells":"pane","tmux.PanePercent":"pane","tmux.PaneText":"pane","tmux.SwapPaneDirection":"pane","tmux.PaneSelectDirection":"pane","workspace.Pane":"pane","tmux.PaneDirectionBelow":"pane","tmux.PaneDirectionAbove":"pane","tmux.PaneDirectionRight":"pane","tmux.PaneDirectionLeft":"pane","tmux.PaneBorderIndicatorsOff":"pane","tmux.PaneBorderIndicatorsColour":"pane","tmux.PaneBorderIndicatorsArrows":"pane","tmux.PaneBorderIndicatorsBoth":"pane","tmux.PaneBorderLinesSingle":"pane","tmux.PaneBorderLinesDouble":"pane","tmux.PaneBorderLinesHeavy":"pane","tmux.PaneBorderLinesSimple":"pane","tmux.PaneBorderLinesNumber":"pane","tmux.PaneBorderLinesSpaces":"pane","tmux.PaneBorderStatusOff":"pane","tmux.PaneBorderStatusTop":"pane","tmux.PaneBorderStatusBottom":"pane","tmux.PaneScrollbarsOff":"pane","tmux.PaneScrollbarsModal":"pane","tmux.PaneScrollbarsOn":"pane","tmux.PaneScrollbarsPositionRight":"pane","tmux.PaneScrollbarsPositionLeft":"pane","tmux.PaneResizeDirectionNone":"pane","tmux.PaneResizeDirectionUp":"pane","tmux.PaneResizeDirectionDown":"pane","tmux.PaneResizeDirectionLeft":"pane","tmux.PaneResizeDirectionRight":"pane","tmux.SwapPaneDirectionNone":"pane","tmux.SwapPaneDirectionUp":"pane","tmux.SwapPaneDirectionDown":"pane","tmux.PaneSelectDirectionNone":"pane","tmux.PaneSelectDirectionUp":"pane","tmux.PaneSelectDirectionDown":"pane","tmux.PaneSelectDirectionLeft":"pane","tmux.PaneSelectDirectionRight":"pane","tmux.PaneSelectDirectionLast":"pane","tmux.ClientAttachment":"client","tmux.ClientName":"client","tmux.Client":"client","tmux.ServerHookValues":"hooks","tmux.SessionHookValues":"hooks","tmux.WindowHookValues":"hooks","tmux.PaneHookValues":"hooks","tmux.AllowPassthrough":"options","tmux.CopyModeLineNumbers":"options","tmux.DestroyUnattached":"options","tmux.DetachOnDestroy":"options","tmux.ExtendedKeys":"options","tmux.GetClipboard":"options","tmux.MenuBorderLines":"options","tmux.MessageLine":"options","tmux.ModeKeys":"options","tmux.PopupBorderLines":"options","tmux.RemainOnExit":"options","tmux.SetClipboard":"options","tmux.Status":"options","tmux.StatusJustify":"options","tmux.StatusKeys":"options","tmux.StatusPosition":"options","tmux.VisualActivity":"options","tmux.VisualBell":"options","tmux.VisualSilence":"options","tmux.OptionOrigin":"options","tmux.OptionValue":"options","tmux.AllowPassthroughOff":"options","tmux.AllowPassthroughOn":"options","tmux.AllowPassthroughAll":"options","tmux.CopyModeLineNumbersOff":"options","tmux.CopyModeLineNumbersDefault":"options","tmux.CopyModeLineNumbersAbsolute":"options","tmux.CopyModeLineNumbersRelative":"options","tmux.CopyModeLineNumbersHybrid":"options","tmux.DestroyUnattachedOff":"options","tmux.DestroyUnattachedOn":"options","tmux.DestroyUnattachedKeepLast":"options","tmux.DestroyUnattachedKeepGroup":"options","tmux.DetachOnDestroyOff":"options","tmux.DetachOnDestroyOn":"options","tmux.DetachOnDestroyNoDetached":"options","tmux.DetachOnDestroyPrevious":"options","tmux.DetachOnDestroyNext":"options","tmux.ExtendedKeysOff":"options","tmux.ExtendedKeysOn":"options","tmux.ExtendedKeysAlways":"options","tmux.GetClipboardOff":"options","tmux.GetClipboardBuffer":"options","tmux.GetClipboardRequest":"options","tmux.GetClipboardBoth":"options","tmux.MenuBorderLinesSingle":"options","tmux.MenuBorderLinesDouble":"options","tmux.MenuBorderLinesHeavy":"options","tmux.MenuBorderLinesSimple":"options","tmux.MenuBorderLinesRounded":"options","tmux.MenuBorderLinesPadded":"options","tmux.MenuBorderLinesNone":"options","tmux.MessageLine0":"options","tmux.MessageLine1":"options","tmux.MessageLine2":"options","tmux.MessageLine3":"options","tmux.MessageLine4":"options","tmux.ModeKeysEmacs":"options","tmux.ModeKeysVi":"options","tmux.PopupBorderLinesSingle":"options","tmux.PopupBorderLinesDouble":"options","tmux.PopupBorderLinesHeavy":"options","tmux.PopupBorderLinesSimple":"options","tmux.PopupBorderLinesRounded":"options","tmux.PopupBorderLinesPadded":"options","tmux.PopupBorderLinesNone":"options","tmux.RemainOnExitOff":"options","tmux.RemainOnExitOn":"options","tmux.RemainOnExitFailed":"options","tmux.RemainOnExitKey":"options","tmux.SetClipboardOff":"options","tmux.SetClipboardExternal":"options","tmux.SetClipboardOn":"options","tmux.StatusOff":"options","tmux.StatusOn":"options","tmux.Status2":"options","tmux.Status3":"options","tmux.Status4":"options","tmux.Status5":"options","tmux.StatusJustifyLeft":"options","tmux.StatusJustifyCentre":"options","tmux.StatusJustifyRight":"options","tmux.StatusJustifyAbsoluteCentre":"options","tmux.StatusKeysEmacs":"options","tmux.StatusKeysVi":"options","tmux.StatusPositionTop":"options","tmux.StatusPositionBottom":"options","tmux.VisualActivityOff":"options","tmux.VisualActivityOn":"options","tmux.VisualActivityBoth":"options","tmux.VisualBellOff":"options","tmux.VisualBellOn":"options","tmux.VisualBellBoth":"options","tmux.VisualSilenceOff":"options","tmux.VisualSilenceOn":"options","tmux.VisualSilenceBoth":"options","tmux.OptionOriginLocal":"options","tmux.OptionOriginInherited":"options","tmux.PrefixKey":"keys","tmux.PrefixPrimary":"keys","tmux.PrefixSecondary":"keys","tmux.EnvironmentValue":"environment","tmux.TerminalFeature":"capabilities","tmux.TerminalFeatures":"capabilities","tmux.TerminalOverrideValue":"capabilities","tmux.TerminalCapability":"capabilities","tmux.TerminalOverride":"capabilities","tmux.TerminalOverrideEntry":"capabilities","tmux.TerminalOverrides":"capabilities","tmux.ModulePath":"version","tmux.PackageVersion":"version","tmux.MinimumSupportedVersion":"version","tmux.MinimumConnectionVersion":"version","tmux.Version":"version","tmux.ParseVersion":"version","tmux.CommandAlias":"commands","tmux.CommandAliases":"commands","tmux.Connection":"commands","tmux.CommandTransport":"commands","tmux.CommandTrace":"commands","tmux.CommandObserver":"commands","tmux.Running":"commands","workspace.Command":"commands","tmux.CommandTransportProcess":"commands","tmux.CommandTransportConnection":"commands","tmux.ControlClient":"control","tmux.ControlNotification":"control","tmux.SubscriptionChange":"control","tmux.ParseControlNotification":"control","tmux.PaneObservation":"control","tmux.NotificationStream":"control","tmux.FormatValues":"formats","tmux.ExtendedKeysFormat":"formats","tmux.ExtendedKeysFormatCSIU":"formats","tmux.ExtendedKeysFormatXTerm":"formats","tmux.Ptr":"queries","tmux.FilterSchemaVersion":"queries","tmux.SessionFilter":"queries","tmux.WindowFilter":"queries","tmux.PaneFilter":"queries","tmux.ClientFilter":"queries","tmux.SessionIDIs":"queries","tmux.SessionNameIs":"queries","tmux.SessionAttachedIs":"queries","tmux.WindowSessionIDIs":"queries","tmux.WindowIDIs":"queries","tmux.WindowIndexIs":"queries","tmux.WindowNameIs":"queries","tmux.WindowActiveIs":"queries","tmux.PaneSessionIDIs":"queries","tmux.PaneWindowIDIs":"queries","tmux.PaneIDIs":"queries","tmux.PaneWindowIndexIs":"queries","tmux.PaneIndexIs":"queries","tmux.PaneCommandIs":"queries","tmux.PaneActiveIs":"queries","tmux.PaneTitleIs":"queries","tmux.ClientNameIs":"queries","tmux.ClientReadOnlyIs":"queries","tmux.WindowRel":"queries","tmux.PaneRel":"queries","tmux.ParseSessionLookup":"queries","tmux.ParseWindowLookup":"queries","tmux.ParsePaneLookup":"queries","tmux.ParseClientLookup":"queries","tmux.TmuxFilter":"queries","tmuxq.Filter":"queries","tmuxq.Matching":"queries","tmuxq.MatchingSeq":"queries","tmuxq.Where":"queries","tmuxq.First":"queries","tmuxq.ExactlyOne":"queries","tmuxq.WhereSeq":"queries","tmuxq.FirstSeq":"queries","tmuxq.ExactlyOneSeq":"queries","tmux.CapturePosition":"snapshots","tmux.CaptureLine":"snapshots","tmux.Snapshot":"snapshots","tmux.CaptureBoundary":"snapshots","tmux.Ref":"workspace","tmux.Op":"workspace","tmux.Dispatch":"workspace","tmux.Sequential":"workspace","tmux.Folding":"workspace","tmux.OpStatus":"workspace","tmux.OpComplete":"workspace","tmux.OpFailed":"workspace","tmux.OpIndeterminate":"workspace","tmux.OpSkipped":"workspace","tmux.Plan":"workspace-plan","tmux.Planner":"workspace-plan","workspace.Workspace":"workspace-plan","tmux.NewPlan":"workspace-plan","tmux.SessionRef":"workspace-session","tmux.WindowRef":"workspace-window","tmux.PaneRef":"workspace-pane","workspace.Build":"workspace-functions","workspace.BuildInto":"workspace-functions","workspace.Parse":"workspace-functions","tmux.DisplayMessageRequest":"requests","tmux.ErrInvalidRequest":"requests","tmux.SubscriptionRequest":"requests","tmux.ErrInvalidCaptureRequest":"requests","tmux.SendKeysRequest":"requests","tmux.SendKeySequenceRequest":"requests","tmux.ClearHistoryRequest":"requests","tmux.CopyModeRequest":"requests","tmux.ChooseTreeRequest":"requests","tmux.DisplayPopupRequest":"requests","tmux.PasteBufferRequest":"requests","tmux.SetPlanOptionRequest":"requests","tmux.PromptHistoryRequest":"requests","tmux.SetBufferRequest":"requests","tmux.SaveBufferRequest":"requests","tmux.LoadBufferRequest":"requests","tmux.ListBuffersRequest":"requests","tmux.RunShellRequest":"requests","tmux.WaitForRequest":"requests","tmux.IfShellRequest":"requests","tmux.SourceFileRequest":"requests","tmux.ConfirmBeforeRequest":"requests","tmux.CommandPromptRequest":"requests","tmux.DisplayMenuRequest":"requests","tmux.BindKeyRequest":"requests","tmux.UnbindKeyRequest":"requests","tmux.ListKeysRequest":"requests","tmux.ListCommandsRequest":"requests","tmux.ShowMessagesRequest":"requests","tmux.SelectLayoutRequest":"requests","tmux.RespawnRequest":"requests","tmux.ServerAccessRequest":"requests-server","tmux.ErrInvalidServerCommandRequest":"requests-server","tmux.SessionKillRequest":"requests-session","tmux.AttachSessionRequest":"requests-session","tmux.HasSessionRequest":"requests-session","tmux.NewSessionRequest":"requests-session","tmux.KillWindowRequest":"requests-window","tmux.FindWindowRequest":"requests-window","tmux.SelectWindowRequest":"requests-window","tmux.NewWindowRequest":"requests-window","tmux.LinkWindowRequest":"requests-window","tmux.UnlinkWindowRequest":"requests-window","tmux.MoveWindowRequest":"requests-window","tmux.SwapWindowRequest":"requests-window","tmux.WindowSelectPaneRequest":"requests-window","tmux.RotateWindowRequest":"requests-window","tmux.ResizeWindowRequest":"requests-window","tmux.PaneDisplayMessageRequest":"requests-pane","tmux.CapturePaneRequest":"requests-pane","tmux.NewPaneRequest":"requests-pane","tmux.SplitPaneRequest":"requests-pane","tmux.ResizePaneRequest":"requests-pane","tmux.DisplayPanesRequest":"requests-pane","tmux.PipePaneRequest":"requests-pane","tmux.MovePaneRequest":"requests-pane","tmux.JoinPaneRequest":"requests-pane","tmux.BreakPaneRequest":"requests-pane","tmux.SwapPaneRequest":"requests-pane","tmux.PaneSelectRequest":"requests-pane","tmux.LastPaneRequest":"requests-pane","tmux.RefreshClientRequest":"requests-client","tmux.DetachClientRequest":"requests-client","tmux.DetachAllClientsRequest":"requests-client","tmux.ErrUnknownColor":"errors","tmux.ErrCommand":"errors","tmux.ErrNotFound":"errors","tmux.ColorError":"errors","tmux.CommandError":"errors","tmux.ErrMalformedComplexOption":"errors","tmux.ComplexOptionDecodeError":"errors","tmux.ErrConnectionRequiresProcess":"errors","tmux.ErrControlClosed":"errors","tmux.ErrControlStreamLost":"errors","tmux.ErrOutcomeUnknown":"errors","tmux.ErrControlReplyCount":"errors","tmux.ErrMalformedControlNotification":"errors","tmux.ErrUnknownControlNotification":"errors","tmux.ControlNotificationError":"errors","tmux.ErrControlNotificationOverflow":"errors","tmux.ControlNotificationOverflowError":"errors","tmux.ErrControlProtocol":"errors","tmux.ControlProtocolError":"errors","tmux.ErrInvalidEnvironmentName":"errors","tmux.ErrInvalidEnvironmentValue":"errors","tmux.ErrMalformedEnvironment":"errors","tmux.EnvironmentNameError":"errors","tmux.EnvironmentValueError":"errors","tmux.EnvironmentDecodeError":"errors","tmux.ErrInvalidFilter":"errors","tmux.ErrMalformedFormatOutput":"errors","tmux.FormatDecodeError":"errors","tmux.ErrNotInsideTmux":"errors","tmux.FromEnvError":"errors","tmux.ErrDaemonReplaced":"errors","tmux.ErrInvalidCommandOutput":"errors","tmux.ErrMalformedOptionOutput":"errors","tmux.OptionDecodeError":"errors","tmux.ErrOption":"errors","tmux.ErrUnknownOption":"errors","tmux.ErrInvalidOption":"errors","tmux.ErrInvalidOptionValue":"errors","tmux.ErrAmbiguousOption":"errors","tmux.ErrOptionTarget":"errors","tmux.OptionValueError":"errors","tmux.OptionError":"errors","tmux.CaptureRequestError":"errors","tmux.ErrPlan":"errors","tmux.PlanError":"errors","tmux.ErrPollCondition":"errors","tmux.ErrMissingSubcommand":"errors","tmux.ErrVersionQuery":"errors","tmux.ErrVersionTooLow":"errors","tmux.VersionQueryError":"errors","tmux.VersionTooLowError":"errors","tmux.ErrOutcomeUnrecorded":"errors","tmux.ErrMalformedSnapshot":"errors","tmux.ErrSnapshotAmbiguous":"errors","tmux.SnapshotDecodeError":"errors","tmux.SnapshotLookupError":"errors","tmux.ErrInvalidSparseIndex":"errors","tmux.ErrDuplicateSparseIndex":"errors","tmux.ErrMissingTarget":"errors","tmux.ErrInvalidTarget":"errors","tmux.TargetError":"errors","tmux.MissingTargetError":"errors","tmux.ErrInvalidVersion":"errors","tmux.VersionError":"errors","tmuxq.ErrNoMatch":"errors","tmuxq.ErrMultipleMatches":"errors","workspace.ErrInvalidWorkspace":"errors","tmux.ErrNoServer":"errors-server","tmux.ServerCommandRequestError":"errors-server","tmux.ErrInvalidServer":"errors-server","tmux.ErrInvalidServerOptions":"errors-server","tmux.ErrSessionExists":"errors-session","tmux.ErrPaneObservationLost":"errors-pane","tmux.ColorMode":"constants","tmux.CommandResult":"constants","tmux.TerminalOverrideValueKind":"constants","tmux.ConnectionOptions":"constants","tmux.ControlCommandResult":"constants","tmux.SetEnvironmentOptions":"constants","tmux.SetHooksOptions":"constants","tmux.SetHooksResult":"constants","tmux.NotificationOptions":"constants","tmux.ActivityAction":"constants","tmux.BellAction":"constants","tmux.ClockModeStyle":"constants","tmux.CursorStyle":"constants","tmux.PromptCommandCursorStyle":"constants","tmux.PromptCursorStyle":"constants","tmux.SilenceAction":"constants","tmux.ControlNotificationKind":"constants","tmux.SetOptionOptions":"constants","tmux.UnsetOptionOptions":"constants","tmux.SetArrayResult":"constants","tmux.PlanResult":"constants","tmux.OpResult":"constants","tmux.LoadBufferFromOptions":"constants","tmux.SaveBufferToOptions":"constants","tmux.WaitForMode":"constants","tmux.RunOptions":"constants","tmux.RunResult":"constants","tmux.WarningKind":"constants","tmux.ColorDefault":"constants","tmux.Color88":"constants","tmux.Color256":"constants","tmux.TerminalOverrideValueFlag":"constants","tmux.TerminalOverrideValueInteger":"constants","tmux.TerminalOverrideValueText":"constants","tmux.ActivityActionNone":"constants","tmux.ActivityActionAny":"constants","tmux.ActivityActionCurrent":"constants","tmux.ActivityActionOther":"constants","tmux.BellActionNone":"constants","tmux.BellActionAny":"constants","tmux.BellActionCurrent":"constants","tmux.BellActionOther":"constants","tmux.ClockModeStyle12":"constants","tmux.ClockModeStyle24":"constants","tmux.ClockModeStyle12WithSeconds":"constants","tmux.ClockModeStyle24WithSeconds":"constants","tmux.CursorStyleDefault":"constants","tmux.CursorStyleBlinkingBlock":"constants","tmux.CursorStyleBlock":"constants","tmux.CursorStyleBlinkingUnderline":"constants","tmux.CursorStyleUnderline":"constants","tmux.CursorStyleBlinkingBar":"constants","tmux.CursorStyleBar":"constants","tmux.PromptCommandCursorStyleDefault":"constants","tmux.PromptCommandCursorStyleBlinkingBlock":"constants","tmux.PromptCommandCursorStyleBlock":"constants","tmux.PromptCommandCursorStyleBlinkingUnderline":"constants","tmux.PromptCommandCursorStyleUnderline":"constants","tmux.PromptCommandCursorStyleBlinkingBar":"constants","tmux.PromptCommandCursorStyleBar":"constants","tmux.PromptCursorStyleDefault":"constants","tmux.PromptCursorStyleBlinkingBlock":"constants","tmux.PromptCursorStyleBlock":"constants","tmux.PromptCursorStyleBlinkingUnderline":"constants","tmux.PromptCursorStyleUnderline":"constants","tmux.PromptCursorStyleBlinkingBar":"constants","tmux.PromptCursorStyleBar":"constants","tmux.SilenceActionNone":"constants","tmux.SilenceActionAny":"constants","tmux.SilenceActionCurrent":"constants","tmux.SilenceActionOther":"constants","tmux.ControlNotificationClientDetached":"constants","tmux.ControlNotificationClientSessionChanged":"constants","tmux.ControlNotificationConfigError":"constants","tmux.ControlNotificationContinue":"constants","tmux.ControlNotificationExit":"constants","tmux.ControlNotificationExtendedOutput":"constants","tmux.ControlNotificationLayoutChange":"constants","tmux.ControlNotificationMessage":"constants","tmux.ControlNotificationOutput":"constants","tmux.ControlNotificationPaneModeChanged":"constants","tmux.ControlNotificationPasteBufferChanged":"constants","tmux.ControlNotificationPasteBufferDeleted":"constants","tmux.ControlNotificationPause":"constants","tmux.ControlNotificationSessionChanged":"constants","tmux.ControlNotificationSessionRenamed":"constants","tmux.ControlNotificationSessionWindowChanged":"constants","tmux.ControlNotificationSessionsChanged":"constants","tmux.ControlNotificationSubscriptionChanged":"constants","tmux.ControlNotificationUnlinkedWindowAdd":"constants","tmux.ControlNotificationUnlinkedWindowClose":"constants","tmux.ControlNotificationUnlinkedWindowRenamed":"constants","tmux.ControlNotificationWindowAdd":"constants","tmux.ControlNotificationWindowClose":"constants","tmux.ControlNotificationWindowPaneChanged":"constants","tmux.ControlNotificationWindowRenamed":"constants","tmux.WaitForModeWait":"constants","tmux.WaitForModeSignal":"constants","tmux.WaitForModeLock":"constants","tmux.WaitForModeUnlock":"constants","tmux.WarningUnsupportedFeature":"constants","tmux.WarningCommandStderr":"constants","tmux.ServerOptions":"constants-server","tmux.AttachSessionOptions":"constants-session","tmux.WindowSwapResult":"constants-window","tmux.PaneSwapResult":"constants-pane","tmux.PaneMarkMode":"constants-pane","tmux.PaneInputMode":"constants-pane","tmux.PaneMarkUnchanged":"constants-pane","tmux.PaneMarkSet":"constants-pane","tmux.PaneMarkClear":"constants-pane","tmux.PaneInputUnchanged":"constants-pane","tmux.PaneInputDisable":"constants-pane","tmux.PaneInputEnable":"constants-pane","mcp.Instance":"mcp","mcp.ServerSession":"mcp","mcp.HandshakeOrdered":"mcp-functions","mcp.MaterializeMinimalConfig":"mcp-functions","mcp.AssumeResponseCommit":"mcp-functions","mcp.NewServer":"mcp-functions","mcp.Run":"mcp-functions","mcp.RunDefaultMinimal":"mcp-functions","mcp.AdvertisedTools":"mcp-functions","mcp.AdvertisedToolsFor":"mcp-functions","mcp.ToolDetails":"mcp-functions","mcp.AuditEnvironmentVariable":"mcp-constants","mcp.ErrInstanceClosed":"mcp-constants","mcp.ErrRequestCapacity":"mcp-constants","mcp.CapabilitiesResourceURI":"mcp-constants","mcp.ErrResponseCommitUnknown":"mcp-constants","mcp.ErrRuntimeTargetBound":"mcp-constants","mcp.Version":"mcp-constants","mcp.CapabilityMetaKey":"mcp-constants","mcp.SocketEnvironmentVariable":"mcp-constants","mcp.SocketPathEnvironmentVariable":"mcp-constants","mcp.TmuxConfigEnvironmentVariable":"mcp-constants","mcp.BinaryEnvironmentVariable":"mcp-constants","mcp.ToolsetsEnvironmentVariable":"mcp-constants","mcp.ToolsEnvironmentVariable":"mcp-constants","mcp.ExcludeToolsEnvironmentVariable":"mcp-constants","mcp.SafetyEnvironmentVariable":"mcp-constants","mcp.RecipeToolEnvironmentVariable":"mcp-constants","mcp.WaitCeilingEnvironmentVariable":"mcp-constants","tmux.MaximumTestedVersion":"testing","tmuxtest.ControlMode":"testing","tmuxtest.ServerOptions":"testing","tmuxtest.ShellPrompt":"testing","tmuxtest.SuiteRootTagVariable":"testing","tmuxtest.Main":"testing","tmuxtest.NewServer":"testing","tmuxtest.NewServerWithOptions":"testing","tmuxtest.PTYProcess":"testing","tmuxtest.StartPTYProcess":"testing","tmuxtest.TemporaryNamePrefix":"testing","tmuxtest.NewSession":"testing","tmuxtest.NewWindow":"testing","tmuxtest.Screen":"testing","tmuxtest.WaitForText":"testing","tmuxtest.WaitForLine":"testing","tmuxtest.WaitForScreen":"testing","tmuxtest.WaitForShellReady":"testing","tmuxtest.Type":"testing","tmuxtest.TypeAndWait":"testing","tmuxtest.RunInPane":"testing","tmuxtest.ScriptedCommand":"testing","tmuxtest.ScriptedTmux":"testing","tmuxtest.WaitFor":"testing","tmuxtest.NewControlMode":"testing","tmux.TreeSortOrder":"__unplaced","tmux.Poll":"__unplaced","tmux.PromptType":"__unplaced","tmux.MenuItem":"__unplaced","tmux.SocketSelection":"__unplaced","tmux.SparseEntry":"__unplaced","tmux.SparseArray":"__unplaced","tmux.UnsupportedPolicy":"__unplaced","tmux.Warning":"__unplaced","tmux.WarningHandler":"__unplaced","workspace.Bool":"__unplaced","tmux.TreeSortDefault":"__unplaced","tmux.TreeSortIndex":"__unplaced","tmux.TreeSortName":"__unplaced","tmux.TreeSortTime":"__unplaced","tmux.TreeSortSize":"__unplaced","tmux.PromptTypeAll":"__unplaced","tmux.PromptTypeCommand":"__unplaced","tmux.PromptTypeSearch":"__unplaced","tmux.PromptTypeTarget":"__unplaced","tmux.PromptTypeWindowTarget":"__unplaced","tmux.NewSparseArray":"__unplaced","tmux.FailUnsupported":"__unplaced","tmux.DegradeUnsupported":"__unplaced"},"unplaced":[{"id":"tmux.TreeSortOrder","name":"TreeSortOrder","slug":"tmux-treesortorder","kind":"struct"},{"id":"tmux.PromptType","name":"PromptType","slug":"tmux-prompttype","kind":"struct"},{"id":"tmux.MenuItem","name":"MenuItem","slug":"tmux-menuitem","kind":"struct"},{"id":"tmux.SocketSelection","name":"SocketSelection","slug":"tmux-socketselection","kind":"struct"},{"id":"tmux.SparseEntry","name":"SparseEntry","slug":"tmux-sparseentry","kind":"struct"},{"id":"tmux.SparseArray","name":"SparseArray","slug":"tmux-sparsearray","kind":"struct"},{"id":"tmux.UnsupportedPolicy","name":"UnsupportedPolicy","slug":"tmux-unsupportedpolicy","kind":"struct"},{"id":"tmux.Warning","name":"Warning","slug":"tmux-warning","kind":"struct"},{"id":"tmux.WarningHandler","name":"WarningHandler","slug":"tmux-warninghandler","kind":"struct"},{"id":"workspace.Bool","name":"Bool","slug":"workspace-bool","kind":"struct"},{"id":"tmux.DegradeUnsupported","name":"DegradeUnsupported","slug":"tmux-degradeunsupported","kind":"constant"},{"id":"tmux.FailUnsupported","name":"FailUnsupported","slug":"tmux-failunsupported","kind":"constant"},{"id":"tmux.PromptTypeAll","name":"PromptTypeAll","slug":"tmux-prompttypeall","kind":"constant"},{"id":"tmux.PromptTypeCommand","name":"PromptTypeCommand","slug":"tmux-prompttypecommand","kind":"constant"},{"id":"tmux.PromptTypeSearch","name":"PromptTypeSearch","slug":"tmux-prompttypesearch","kind":"constant"},{"id":"tmux.PromptTypeTarget","name":"PromptTypeTarget","slug":"tmux-prompttypetarget","kind":"constant"},{"id":"tmux.PromptTypeWindowTarget","name":"PromptTypeWindowTarget","slug":"tmux-prompttypewindowtarget","kind":"constant"},{"id":"tmux.TreeSortDefault","name":"TreeSortDefault","slug":"tmux-treesortdefault","kind":"constant"},{"id":"tmux.TreeSortIndex","name":"TreeSortIndex","slug":"tmux-treesortindex","kind":"constant"},{"id":"tmux.TreeSortName","name":"TreeSortName","slug":"tmux-treesortname","kind":"constant"},{"id":"tmux.TreeSortSize","name":"TreeSortSize","slug":"tmux-treesortsize","kind":"constant"},{"id":"tmux.TreeSortTime","name":"TreeSortTime","slug":"tmux-treesorttime","kind":"constant"},{"id":"tmux.NewSparseArray","name":"NewSparseArray","slug":"tmux-newsparsearray","kind":"function"},{"id":"tmux.Poll","name":"Poll","slug":"tmux-poll","kind":"function"}],"diagnostics":{"unmatched":[],"deadBuckets":["options-functions","options-constants","buffers","layout","queries-fields","queries-operators","queries-expressions","workspace-steps","workspace-targets","workspace-constants","errors-window","constants-client","runtime","async","internal","internal-commands","internal-options"],"ambiguous":[],"staleUnsettled":[]}}
+{"port":"go","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":"tmux.ServerOptionValues","name":"ServerOptionValues","slug":"tmux-serveroptionvalues","kind":"struct"},{"id":"tmux.Server","name":"Server","slug":"tmux-server","kind":"struct"},{"id":"tmux.NewServer","name":"NewServer","slug":"tmux-newserver","kind":"function"},{"id":"tmux.NewServerFromEnv","name":"NewServerFromEnv","slug":"tmux-newserverfromenv","kind":"function"}],"session":[{"id":"tmux.SessionID","name":"SessionID","slug":"tmux-sessionid","kind":"struct"},{"id":"tmux.Session","name":"Session","slug":"tmux-session","kind":"struct"},{"id":"tmux.SessionOptionValues","name":"SessionOptionValues","slug":"tmux-sessionoptionvalues","kind":"struct"},{"id":"tmux.GlobalSessionScope","name":"GlobalSessionScope","slug":"tmux-globalsessionscope","kind":"struct"},{"id":"tmux.SessionFromEnv","name":"SessionFromEnv","slug":"tmux-sessionfromenv","kind":"function"},{"id":"tmux.ValidateSessionName","name":"ValidateSessionName","slug":"tmux-validatesessionname","kind":"function"}],"window":[{"id":"tmux.WindowID","name":"WindowID","slug":"tmux-windowid","kind":"struct"},{"id":"tmux.Window","name":"Window","slug":"tmux-window","kind":"struct"},{"id":"tmux.WindowSize","name":"WindowSize","slug":"tmux-windowsize","kind":"struct"},{"id":"tmux.WindowOptionValues","name":"WindowOptionValues","slug":"tmux-windowoptionvalues","kind":"struct"},{"id":"tmux.GlobalWindowScope","name":"GlobalWindowScope","slug":"tmux-globalwindowscope","kind":"struct"},{"id":"tmux.NewWindowDirection","name":"NewWindowDirection","slug":"tmux-newwindowdirection","kind":"struct"},{"id":"tmux.RotateWindowDirection","name":"RotateWindowDirection","slug":"tmux-rotatewindowdirection","kind":"struct"},{"id":"tmux.WindowResizeDirection","name":"WindowResizeDirection","slug":"tmux-windowresizedirection","kind":"struct"},{"id":"workspace.Window","name":"Window","slug":"workspace-window","kind":"struct"},{"id":"tmux.NewWindowDirectionAfter","name":"NewWindowDirectionAfter","slug":"tmux-newwindowdirectionafter","kind":"constant"},{"id":"tmux.NewWindowDirectionBefore","name":"NewWindowDirectionBefore","slug":"tmux-newwindowdirectionbefore","kind":"constant"},{"id":"tmux.NewWindowDirectionDefault","name":"NewWindowDirectionDefault","slug":"tmux-newwindowdirectiondefault","kind":"constant"},{"id":"tmux.RotateWindowDefault","name":"RotateWindowDefault","slug":"tmux-rotatewindowdefault","kind":"constant"},{"id":"tmux.RotateWindowDown","name":"RotateWindowDown","slug":"tmux-rotatewindowdown","kind":"constant"},{"id":"tmux.RotateWindowUp","name":"RotateWindowUp","slug":"tmux-rotatewindowup","kind":"constant"},{"id":"tmux.WindowResizeDirectionDown","name":"WindowResizeDirectionDown","slug":"tmux-windowresizedirectiondown","kind":"constant"},{"id":"tmux.WindowResizeDirectionLeft","name":"WindowResizeDirectionLeft","slug":"tmux-windowresizedirectionleft","kind":"constant"},{"id":"tmux.WindowResizeDirectionNone","name":"WindowResizeDirectionNone","slug":"tmux-windowresizedirectionnone","kind":"constant"},{"id":"tmux.WindowResizeDirectionRight","name":"WindowResizeDirectionRight","slug":"tmux-windowresizedirectionright","kind":"constant"},{"id":"tmux.WindowResizeDirectionUp","name":"WindowResizeDirectionUp","slug":"tmux-windowresizedirectionup","kind":"constant"},{"id":"tmux.WindowSizeLargest","name":"WindowSizeLargest","slug":"tmux-windowsizelargest","kind":"constant"},{"id":"tmux.WindowSizeLatest","name":"WindowSizeLatest","slug":"tmux-windowsizelatest","kind":"constant"},{"id":"tmux.WindowSizeManual","name":"WindowSizeManual","slug":"tmux-windowsizemanual","kind":"constant"},{"id":"tmux.WindowSizeSmallest","name":"WindowSizeSmallest","slug":"tmux-windowsizesmallest","kind":"constant"},{"id":"tmux.WindowFromEnv","name":"WindowFromEnv","slug":"tmux-windowfromenv","kind":"function"}],"pane":[{"id":"tmux.PaneDirection","name":"PaneDirection","slug":"tmux-panedirection","kind":"struct"},{"id":"tmux.PaneID","name":"PaneID","slug":"tmux-paneid","kind":"struct"},{"id":"tmux.Pane","name":"Pane","slug":"tmux-pane","kind":"struct"},{"id":"tmux.PaneBorderIndicators","name":"PaneBorderIndicators","slug":"tmux-paneborderindicators","kind":"struct"},{"id":"tmux.PaneBorderLines","name":"PaneBorderLines","slug":"tmux-paneborderlines","kind":"struct"},{"id":"tmux.PaneBorderStatus","name":"PaneBorderStatus","slug":"tmux-paneborderstatus","kind":"struct"},{"id":"tmux.PaneScrollbars","name":"PaneScrollbars","slug":"tmux-panescrollbars","kind":"struct"},{"id":"tmux.PaneScrollbarsPosition","name":"PaneScrollbarsPosition","slug":"tmux-panescrollbarsposition","kind":"struct"},{"id":"tmux.PaneOptionValues","name":"PaneOptionValues","slug":"tmux-paneoptionvalues","kind":"struct"},{"id":"tmux.PaneResizeDirection","name":"PaneResizeDirection","slug":"tmux-paneresizedirection","kind":"struct"},{"id":"tmux.PaneSize","name":"PaneSize","slug":"tmux-panesize","kind":"struct"},{"id":"tmux.PaneText","name":"PaneText","slug":"tmux-panetext","kind":"struct"},{"id":"tmux.SwapPaneDirection","name":"SwapPaneDirection","slug":"tmux-swappanedirection","kind":"struct"},{"id":"tmux.PaneSelectDirection","name":"PaneSelectDirection","slug":"tmux-paneselectdirection","kind":"struct"},{"id":"workspace.Pane","name":"Pane","slug":"workspace-pane","kind":"struct"},{"id":"tmux.PaneBorderIndicatorsArrows","name":"PaneBorderIndicatorsArrows","slug":"tmux-paneborderindicatorsarrows","kind":"constant"},{"id":"tmux.PaneBorderIndicatorsBoth","name":"PaneBorderIndicatorsBoth","slug":"tmux-paneborderindicatorsboth","kind":"constant"},{"id":"tmux.PaneBorderIndicatorsColour","name":"PaneBorderIndicatorsColour","slug":"tmux-paneborderindicatorscolour","kind":"constant"},{"id":"tmux.PaneBorderIndicatorsOff","name":"PaneBorderIndicatorsOff","slug":"tmux-paneborderindicatorsoff","kind":"constant"},{"id":"tmux.PaneBorderLinesDouble","name":"PaneBorderLinesDouble","slug":"tmux-paneborderlinesdouble","kind":"constant"},{"id":"tmux.PaneBorderLinesHeavy","name":"PaneBorderLinesHeavy","slug":"tmux-paneborderlinesheavy","kind":"constant"},{"id":"tmux.PaneBorderLinesNumber","name":"PaneBorderLinesNumber","slug":"tmux-paneborderlinesnumber","kind":"constant"},{"id":"tmux.PaneBorderLinesSimple","name":"PaneBorderLinesSimple","slug":"tmux-paneborderlinessimple","kind":"constant"},{"id":"tmux.PaneBorderLinesSingle","name":"PaneBorderLinesSingle","slug":"tmux-paneborderlinessingle","kind":"constant"},{"id":"tmux.PaneBorderLinesSpaces","name":"PaneBorderLinesSpaces","slug":"tmux-paneborderlinesspaces","kind":"constant"},{"id":"tmux.PaneBorderStatusBottom","name":"PaneBorderStatusBottom","slug":"tmux-paneborderstatusbottom","kind":"constant"},{"id":"tmux.PaneBorderStatusOff","name":"PaneBorderStatusOff","slug":"tmux-paneborderstatusoff","kind":"constant"},{"id":"tmux.PaneBorderStatusTop","name":"PaneBorderStatusTop","slug":"tmux-paneborderstatustop","kind":"constant"},{"id":"tmux.PaneDirectionAbove","name":"PaneDirectionAbove","slug":"tmux-panedirectionabove","kind":"constant"},{"id":"tmux.PaneDirectionBelow","name":"PaneDirectionBelow","slug":"tmux-panedirectionbelow","kind":"constant"},{"id":"tmux.PaneDirectionLeft","name":"PaneDirectionLeft","slug":"tmux-panedirectionleft","kind":"constant"},{"id":"tmux.PaneDirectionRight","name":"PaneDirectionRight","slug":"tmux-panedirectionright","kind":"constant"},{"id":"tmux.PaneResizeDirectionDown","name":"PaneResizeDirectionDown","slug":"tmux-paneresizedirectiondown","kind":"constant"},{"id":"tmux.PaneResizeDirectionLeft","name":"PaneResizeDirectionLeft","slug":"tmux-paneresizedirectionleft","kind":"constant"},{"id":"tmux.PaneResizeDirectionNone","name":"PaneResizeDirectionNone","slug":"tmux-paneresizedirectionnone","kind":"constant"},{"id":"tmux.PaneResizeDirectionRight","name":"PaneResizeDirectionRight","slug":"tmux-paneresizedirectionright","kind":"constant"},{"id":"tmux.PaneResizeDirectionUp","name":"PaneResizeDirectionUp","slug":"tmux-paneresizedirectionup","kind":"constant"},{"id":"tmux.PaneScrollbarsModal","name":"PaneScrollbarsModal","slug":"tmux-panescrollbarsmodal","kind":"constant"},{"id":"tmux.PaneScrollbarsOff","name":"PaneScrollbarsOff","slug":"tmux-panescrollbarsoff","kind":"constant"},{"id":"tmux.PaneScrollbarsOn","name":"PaneScrollbarsOn","slug":"tmux-panescrollbarson","kind":"constant"},{"id":"tmux.PaneScrollbarsPositionLeft","name":"PaneScrollbarsPositionLeft","slug":"tmux-panescrollbarspositionleft","kind":"constant"},{"id":"tmux.PaneScrollbarsPositionRight","name":"PaneScrollbarsPositionRight","slug":"tmux-panescrollbarspositionright","kind":"constant"},{"id":"tmux.PaneSelectDirectionDown","name":"PaneSelectDirectionDown","slug":"tmux-paneselectdirectiondown","kind":"constant"},{"id":"tmux.PaneSelectDirectionLast","name":"PaneSelectDirectionLast","slug":"tmux-paneselectdirectionlast","kind":"constant"},{"id":"tmux.PaneSelectDirectionLeft","name":"PaneSelectDirectionLeft","slug":"tmux-paneselectdirectionleft","kind":"constant"},{"id":"tmux.PaneSelectDirectionNone","name":"PaneSelectDirectionNone","slug":"tmux-paneselectdirectionnone","kind":"constant"},{"id":"tmux.PaneSelectDirectionRight","name":"PaneSelectDirectionRight","slug":"tmux-paneselectdirectionright","kind":"constant"},{"id":"tmux.PaneSelectDirectionUp","name":"PaneSelectDirectionUp","slug":"tmux-paneselectdirectionup","kind":"constant"},{"id":"tmux.SwapPaneDirectionDown","name":"SwapPaneDirectionDown","slug":"tmux-swappanedirectiondown","kind":"constant"},{"id":"tmux.SwapPaneDirectionNone","name":"SwapPaneDirectionNone","slug":"tmux-swappanedirectionnone","kind":"constant"},{"id":"tmux.SwapPaneDirectionUp","name":"SwapPaneDirectionUp","slug":"tmux-swappanedirectionup","kind":"constant"},{"id":"tmux.PaneCells","name":"PaneCells","slug":"tmux-panecells","kind":"function"},{"id":"tmux.PaneFromEnv","name":"PaneFromEnv","slug":"tmux-panefromenv","kind":"function"},{"id":"tmux.PanePercent","name":"PanePercent","slug":"tmux-panepercent","kind":"function"}],"client":[{"id":"tmux.ClientAttachment","name":"ClientAttachment","slug":"tmux-clientattachment","kind":"struct"},{"id":"tmux.ClientName","name":"ClientName","slug":"tmux-clientname","kind":"struct"},{"id":"tmux.Client","name":"Client","slug":"tmux-client","kind":"struct"}],"hooks":[{"id":"tmux.ServerHookValues","name":"ServerHookValues","slug":"tmux-serverhookvalues","kind":"struct"},{"id":"tmux.SessionHookValues","name":"SessionHookValues","slug":"tmux-sessionhookvalues","kind":"struct"},{"id":"tmux.WindowHookValues","name":"WindowHookValues","slug":"tmux-windowhookvalues","kind":"struct"},{"id":"tmux.PaneHookValues","name":"PaneHookValues","slug":"tmux-panehookvalues","kind":"struct"}],"options":[{"id":"tmux.AllowPassthrough","name":"AllowPassthrough","slug":"tmux-allowpassthrough","kind":"struct"},{"id":"tmux.CopyModeLineNumbers","name":"CopyModeLineNumbers","slug":"tmux-copymodelinenumbers","kind":"struct"},{"id":"tmux.DestroyUnattached","name":"DestroyUnattached","slug":"tmux-destroyunattached","kind":"struct"},{"id":"tmux.DetachOnDestroy","name":"DetachOnDestroy","slug":"tmux-detachondestroy","kind":"struct"},{"id":"tmux.ExtendedKeys","name":"ExtendedKeys","slug":"tmux-extendedkeys","kind":"struct"},{"id":"tmux.GetClipboard","name":"GetClipboard","slug":"tmux-getclipboard","kind":"struct"},{"id":"tmux.MenuBorderLines","name":"MenuBorderLines","slug":"tmux-menuborderlines","kind":"struct"},{"id":"tmux.MessageLine","name":"MessageLine","slug":"tmux-messageline","kind":"struct"},{"id":"tmux.ModeKeys","name":"ModeKeys","slug":"tmux-modekeys","kind":"struct"},{"id":"tmux.PopupBorderLines","name":"PopupBorderLines","slug":"tmux-popupborderlines","kind":"struct"},{"id":"tmux.RemainOnExit","name":"RemainOnExit","slug":"tmux-remainonexit","kind":"struct"},{"id":"tmux.SetClipboard","name":"SetClipboard","slug":"tmux-setclipboard","kind":"struct"},{"id":"tmux.Status","name":"Status","slug":"tmux-status","kind":"struct"},{"id":"tmux.StatusJustify","name":"StatusJustify","slug":"tmux-statusjustify","kind":"struct"},{"id":"tmux.StatusKeys","name":"StatusKeys","slug":"tmux-statuskeys","kind":"struct"},{"id":"tmux.StatusPosition","name":"StatusPosition","slug":"tmux-statusposition","kind":"struct"},{"id":"tmux.VisualActivity","name":"VisualActivity","slug":"tmux-visualactivity","kind":"struct"},{"id":"tmux.VisualBell","name":"VisualBell","slug":"tmux-visualbell","kind":"struct"},{"id":"tmux.VisualSilence","name":"VisualSilence","slug":"tmux-visualsilence","kind":"struct"},{"id":"tmux.OptionOrigin","name":"OptionOrigin","slug":"tmux-optionorigin","kind":"struct"},{"id":"tmux.OptionValue","name":"OptionValue","slug":"tmux-optionvalue","kind":"struct"},{"id":"tmux.AllowPassthroughAll","name":"AllowPassthroughAll","slug":"tmux-allowpassthroughall","kind":"constant"},{"id":"tmux.AllowPassthroughOff","name":"AllowPassthroughOff","slug":"tmux-allowpassthroughoff","kind":"constant"},{"id":"tmux.AllowPassthroughOn","name":"AllowPassthroughOn","slug":"tmux-allowpassthroughon","kind":"constant"},{"id":"tmux.CopyModeLineNumbersAbsolute","name":"CopyModeLineNumbersAbsolute","slug":"tmux-copymodelinenumbersabsolute","kind":"constant"},{"id":"tmux.CopyModeLineNumbersDefault","name":"CopyModeLineNumbersDefault","slug":"tmux-copymodelinenumbersdefault","kind":"constant"},{"id":"tmux.CopyModeLineNumbersHybrid","name":"CopyModeLineNumbersHybrid","slug":"tmux-copymodelinenumbershybrid","kind":"constant"},{"id":"tmux.CopyModeLineNumbersOff","name":"CopyModeLineNumbersOff","slug":"tmux-copymodelinenumbersoff","kind":"constant"},{"id":"tmux.CopyModeLineNumbersRelative","name":"CopyModeLineNumbersRelative","slug":"tmux-copymodelinenumbersrelative","kind":"constant"},{"id":"tmux.DestroyUnattachedKeepGroup","name":"DestroyUnattachedKeepGroup","slug":"tmux-destroyunattachedkeepgroup","kind":"constant"},{"id":"tmux.DestroyUnattachedKeepLast","name":"DestroyUnattachedKeepLast","slug":"tmux-destroyunattachedkeeplast","kind":"constant"},{"id":"tmux.DestroyUnattachedOff","name":"DestroyUnattachedOff","slug":"tmux-destroyunattachedoff","kind":"constant"},{"id":"tmux.DestroyUnattachedOn","name":"DestroyUnattachedOn","slug":"tmux-destroyunattachedon","kind":"constant"},{"id":"tmux.DetachOnDestroyNext","name":"DetachOnDestroyNext","slug":"tmux-detachondestroynext","kind":"constant"},{"id":"tmux.DetachOnDestroyNoDetached","name":"DetachOnDestroyNoDetached","slug":"tmux-detachondestroynodetached","kind":"constant"},{"id":"tmux.DetachOnDestroyOff","name":"DetachOnDestroyOff","slug":"tmux-detachondestroyoff","kind":"constant"},{"id":"tmux.DetachOnDestroyOn","name":"DetachOnDestroyOn","slug":"tmux-detachondestroyon","kind":"constant"},{"id":"tmux.DetachOnDestroyPrevious","name":"DetachOnDestroyPrevious","slug":"tmux-detachondestroyprevious","kind":"constant"},{"id":"tmux.ExtendedKeysAlways","name":"ExtendedKeysAlways","slug":"tmux-extendedkeysalways","kind":"constant"},{"id":"tmux.ExtendedKeysOff","name":"ExtendedKeysOff","slug":"tmux-extendedkeysoff","kind":"constant"},{"id":"tmux.ExtendedKeysOn","name":"ExtendedKeysOn","slug":"tmux-extendedkeyson","kind":"constant"},{"id":"tmux.GetClipboardBoth","name":"GetClipboardBoth","slug":"tmux-getclipboardboth","kind":"constant"},{"id":"tmux.GetClipboardBuffer","name":"GetClipboardBuffer","slug":"tmux-getclipboardbuffer","kind":"constant"},{"id":"tmux.GetClipboardOff","name":"GetClipboardOff","slug":"tmux-getclipboardoff","kind":"constant"},{"id":"tmux.GetClipboardRequest","name":"GetClipboardRequest","slug":"tmux-getclipboardrequest","kind":"constant"},{"id":"tmux.MenuBorderLinesDouble","name":"MenuBorderLinesDouble","slug":"tmux-menuborderlinesdouble","kind":"constant"},{"id":"tmux.MenuBorderLinesHeavy","name":"MenuBorderLinesHeavy","slug":"tmux-menuborderlinesheavy","kind":"constant"},{"id":"tmux.MenuBorderLinesNone","name":"MenuBorderLinesNone","slug":"tmux-menuborderlinesnone","kind":"constant"},{"id":"tmux.MenuBorderLinesPadded","name":"MenuBorderLinesPadded","slug":"tmux-menuborderlinespadded","kind":"constant"},{"id":"tmux.MenuBorderLinesRounded","name":"MenuBorderLinesRounded","slug":"tmux-menuborderlinesrounded","kind":"constant"},{"id":"tmux.MenuBorderLinesSimple","name":"MenuBorderLinesSimple","slug":"tmux-menuborderlinessimple","kind":"constant"},{"id":"tmux.MenuBorderLinesSingle","name":"MenuBorderLinesSingle","slug":"tmux-menuborderlinessingle","kind":"constant"},{"id":"tmux.MessageLine0","name":"MessageLine0","slug":"tmux-messageline0","kind":"constant"},{"id":"tmux.MessageLine1","name":"MessageLine1","slug":"tmux-messageline1","kind":"constant"},{"id":"tmux.MessageLine2","name":"MessageLine2","slug":"tmux-messageline2","kind":"constant"},{"id":"tmux.MessageLine3","name":"MessageLine3","slug":"tmux-messageline3","kind":"constant"},{"id":"tmux.MessageLine4","name":"MessageLine4","slug":"tmux-messageline4","kind":"constant"},{"id":"tmux.ModeKeysEmacs","name":"ModeKeysEmacs","slug":"tmux-modekeysemacs","kind":"constant"},{"id":"tmux.ModeKeysVi","name":"ModeKeysVi","slug":"tmux-modekeysvi","kind":"constant"},{"id":"tmux.OptionOriginInherited","name":"OptionOriginInherited","slug":"tmux-optionorigininherited","kind":"constant"},{"id":"tmux.OptionOriginLocal","name":"OptionOriginLocal","slug":"tmux-optionoriginlocal","kind":"constant"},{"id":"tmux.PopupBorderLinesDouble","name":"PopupBorderLinesDouble","slug":"tmux-popupborderlinesdouble","kind":"constant"},{"id":"tmux.PopupBorderLinesHeavy","name":"PopupBorderLinesHeavy","slug":"tmux-popupborderlinesheavy","kind":"constant"},{"id":"tmux.PopupBorderLinesNone","name":"PopupBorderLinesNone","slug":"tmux-popupborderlinesnone","kind":"constant"},{"id":"tmux.PopupBorderLinesPadded","name":"PopupBorderLinesPadded","slug":"tmux-popupborderlinespadded","kind":"constant"},{"id":"tmux.PopupBorderLinesRounded","name":"PopupBorderLinesRounded","slug":"tmux-popupborderlinesrounded","kind":"constant"},{"id":"tmux.PopupBorderLinesSimple","name":"PopupBorderLinesSimple","slug":"tmux-popupborderlinessimple","kind":"constant"},{"id":"tmux.PopupBorderLinesSingle","name":"PopupBorderLinesSingle","slug":"tmux-popupborderlinessingle","kind":"constant"},{"id":"tmux.RemainOnExitFailed","name":"RemainOnExitFailed","slug":"tmux-remainonexitfailed","kind":"constant"},{"id":"tmux.RemainOnExitKey","name":"RemainOnExitKey","slug":"tmux-remainonexitkey","kind":"constant"},{"id":"tmux.RemainOnExitOff","name":"RemainOnExitOff","slug":"tmux-remainonexitoff","kind":"constant"},{"id":"tmux.RemainOnExitOn","name":"RemainOnExitOn","slug":"tmux-remainonexiton","kind":"constant"},{"id":"tmux.SetClipboardExternal","name":"SetClipboardExternal","slug":"tmux-setclipboardexternal","kind":"constant"},{"id":"tmux.SetClipboardOff","name":"SetClipboardOff","slug":"tmux-setclipboardoff","kind":"constant"},{"id":"tmux.SetClipboardOn","name":"SetClipboardOn","slug":"tmux-setclipboardon","kind":"constant"},{"id":"tmux.Status2","name":"Status2","slug":"tmux-status2","kind":"constant"},{"id":"tmux.Status3","name":"Status3","slug":"tmux-status3","kind":"constant"},{"id":"tmux.Status4","name":"Status4","slug":"tmux-status4","kind":"constant"},{"id":"tmux.Status5","name":"Status5","slug":"tmux-status5","kind":"constant"},{"id":"tmux.StatusJustifyAbsoluteCentre","name":"StatusJustifyAbsoluteCentre","slug":"tmux-statusjustifyabsolutecentre","kind":"constant"},{"id":"tmux.StatusJustifyCentre","name":"StatusJustifyCentre","slug":"tmux-statusjustifycentre","kind":"constant"},{"id":"tmux.StatusJustifyLeft","name":"StatusJustifyLeft","slug":"tmux-statusjustifyleft","kind":"constant"},{"id":"tmux.StatusJustifyRight","name":"StatusJustifyRight","slug":"tmux-statusjustifyright","kind":"constant"},{"id":"tmux.StatusKeysEmacs","name":"StatusKeysEmacs","slug":"tmux-statuskeysemacs","kind":"constant"},{"id":"tmux.StatusKeysVi","name":"StatusKeysVi","slug":"tmux-statuskeysvi","kind":"constant"},{"id":"tmux.StatusOff","name":"StatusOff","slug":"tmux-statusoff","kind":"constant"},{"id":"tmux.StatusOn","name":"StatusOn","slug":"tmux-statuson","kind":"constant"},{"id":"tmux.StatusPositionBottom","name":"StatusPositionBottom","slug":"tmux-statuspositionbottom","kind":"constant"},{"id":"tmux.StatusPositionTop","name":"StatusPositionTop","slug":"tmux-statuspositiontop","kind":"constant"},{"id":"tmux.VisualActivityBoth","name":"VisualActivityBoth","slug":"tmux-visualactivityboth","kind":"constant"},{"id":"tmux.VisualActivityOff","name":"VisualActivityOff","slug":"tmux-visualactivityoff","kind":"constant"},{"id":"tmux.VisualActivityOn","name":"VisualActivityOn","slug":"tmux-visualactivityon","kind":"constant"},{"id":"tmux.VisualBellBoth","name":"VisualBellBoth","slug":"tmux-visualbellboth","kind":"constant"},{"id":"tmux.VisualBellOff","name":"VisualBellOff","slug":"tmux-visualbelloff","kind":"constant"},{"id":"tmux.VisualBellOn","name":"VisualBellOn","slug":"tmux-visualbellon","kind":"constant"},{"id":"tmux.VisualSilenceBoth","name":"VisualSilenceBoth","slug":"tmux-visualsilenceboth","kind":"constant"},{"id":"tmux.VisualSilenceOff","name":"VisualSilenceOff","slug":"tmux-visualsilenceoff","kind":"constant"},{"id":"tmux.VisualSilenceOn","name":"VisualSilenceOn","slug":"tmux-visualsilenceon","kind":"constant"}],"options-functions":[],"options-constants":[],"keys":[{"id":"tmux.PrefixKey","name":"PrefixKey","slug":"tmux-prefixkey","kind":"struct"},{"id":"tmux.PrefixPrimary","name":"PrefixPrimary","slug":"tmux-prefixprimary","kind":"constant"},{"id":"tmux.PrefixSecondary","name":"PrefixSecondary","slug":"tmux-prefixsecondary","kind":"constant"}],"buffers":[],"layout":[],"environment":[{"id":"tmux.EnvironmentValue","name":"EnvironmentValue","slug":"tmux-environmentvalue","kind":"struct"}],"capabilities":[{"id":"tmux.TerminalFeature","name":"TerminalFeature","slug":"tmux-terminalfeature","kind":"struct"},{"id":"tmux.TerminalFeatures","name":"TerminalFeatures","slug":"tmux-terminalfeatures","kind":"struct"},{"id":"tmux.TerminalOverrideValue","name":"TerminalOverrideValue","slug":"tmux-terminaloverridevalue","kind":"struct"},{"id":"tmux.TerminalCapability","name":"TerminalCapability","slug":"tmux-terminalcapability","kind":"struct"},{"id":"tmux.TerminalOverride","name":"TerminalOverride","slug":"tmux-terminaloverride","kind":"struct"},{"id":"tmux.TerminalOverrideEntry","name":"TerminalOverrideEntry","slug":"tmux-terminaloverrideentry","kind":"struct"},{"id":"tmux.TerminalOverrides","name":"TerminalOverrides","slug":"tmux-terminaloverrides","kind":"struct"}],"version":[{"id":"tmux.Version","name":"Version","slug":"tmux-version","kind":"struct"},{"id":"tmux.MinimumConnectionVersion","name":"MinimumConnectionVersion","slug":"tmux-minimumconnectionversion","kind":"constant"},{"id":"tmux.MinimumSupportedVersion","name":"MinimumSupportedVersion","slug":"tmux-minimumsupportedversion","kind":"constant"},{"id":"tmux.ModulePath","name":"ModulePath","slug":"tmux-modulepath","kind":"constant"},{"id":"tmux.PackageVersion","name":"PackageVersion","slug":"tmux-packageversion","kind":"function"},{"id":"tmux.ParseVersion","name":"ParseVersion","slug":"tmux-parseversion","kind":"function"}],"commands":[{"id":"tmux.CommandAlias","name":"CommandAlias","slug":"tmux-commandalias","kind":"struct"},{"id":"tmux.CommandAliases","name":"CommandAliases","slug":"tmux-commandaliases","kind":"struct"},{"id":"tmux.Connection","name":"Connection","slug":"tmux-connection","kind":"struct"},{"id":"tmux.CommandTransport","name":"CommandTransport","slug":"tmux-commandtransport","kind":"struct"},{"id":"tmux.CommandTrace","name":"CommandTrace","slug":"tmux-commandtrace","kind":"struct"},{"id":"tmux.CommandObserver","name":"CommandObserver","slug":"tmux-commandobserver","kind":"struct"},{"id":"tmux.Running","name":"Running","slug":"tmux-running","kind":"struct"},{"id":"workspace.Command","name":"Command","slug":"workspace-command","kind":"struct"},{"id":"tmux.CommandTransportConnection","name":"CommandTransportConnection","slug":"tmux-commandtransportconnection","kind":"constant"},{"id":"tmux.CommandTransportProcess","name":"CommandTransportProcess","slug":"tmux-commandtransportprocess","kind":"constant"}],"control":[{"id":"tmux.ControlClient","name":"ControlClient","slug":"tmux-controlclient","kind":"struct"},{"id":"tmux.ControlNotification","name":"ControlNotification","slug":"tmux-controlnotification","kind":"struct"},{"id":"tmux.SubscriptionChange","name":"SubscriptionChange","slug":"tmux-subscriptionchange","kind":"struct"},{"id":"tmux.PaneObservation","name":"PaneObservation","slug":"tmux-paneobservation","kind":"struct"},{"id":"tmux.NotificationStream","name":"NotificationStream","slug":"tmux-notificationstream","kind":"struct"},{"id":"tmux.ParseControlNotification","name":"ParseControlNotification","slug":"tmux-parsecontrolnotification","kind":"function"}],"formats":[{"id":"tmux.FormatValues","name":"FormatValues","slug":"tmux-formatvalues","kind":"struct"},{"id":"tmux.ExtendedKeysFormat","name":"ExtendedKeysFormat","slug":"tmux-extendedkeysformat","kind":"struct"},{"id":"tmux.ExtendedKeysFormatCSIU","name":"ExtendedKeysFormatCSIU","slug":"tmux-extendedkeysformatcsiu","kind":"constant"},{"id":"tmux.ExtendedKeysFormatXTerm","name":"ExtendedKeysFormatXTerm","slug":"tmux-extendedkeysformatxterm","kind":"constant"}],"queries":[{"id":"tmux.SessionFilter","name":"SessionFilter","slug":"tmux-sessionfilter","kind":"struct"},{"id":"tmux.WindowFilter","name":"WindowFilter","slug":"tmux-windowfilter","kind":"struct"},{"id":"tmux.PaneFilter","name":"PaneFilter","slug":"tmux-panefilter","kind":"struct"},{"id":"tmux.ClientFilter","name":"ClientFilter","slug":"tmux-clientfilter","kind":"struct"},{"id":"tmux.WindowRel","name":"WindowRel","slug":"tmux-windowrel","kind":"struct"},{"id":"tmux.PaneRel","name":"PaneRel","slug":"tmux-panerel","kind":"struct"},{"id":"tmux.TmuxFilter","name":"TmuxFilter","slug":"tmux-tmuxfilter","kind":"struct"},{"id":"tmuxq.Filter","name":"Filter","slug":"tmuxq-filter","kind":"struct"},{"id":"tmux.FilterSchemaVersion","name":"FilterSchemaVersion","slug":"tmux-filterschemaversion","kind":"constant"},{"id":"tmux.ClientNameIs","name":"ClientNameIs","slug":"tmux-clientnameis","kind":"function"},{"id":"tmux.ClientReadOnlyIs","name":"ClientReadOnlyIs","slug":"tmux-clientreadonlyis","kind":"function"},{"id":"tmuxq.ExactlyOne","name":"ExactlyOne","slug":"tmuxq-exactlyone","kind":"function"},{"id":"tmuxq.ExactlyOneSeq","name":"ExactlyOneSeq","slug":"tmuxq-exactlyoneseq","kind":"function"},{"id":"tmuxq.First","name":"First","slug":"tmuxq-first","kind":"function"},{"id":"tmuxq.FirstSeq","name":"FirstSeq","slug":"tmuxq-firstseq","kind":"function"},{"id":"tmuxq.Matching","name":"Matching","slug":"tmuxq-matching","kind":"function"},{"id":"tmuxq.MatchingSeq","name":"MatchingSeq","slug":"tmuxq-matchingseq","kind":"function"},{"id":"tmux.PaneActiveIs","name":"PaneActiveIs","slug":"tmux-paneactiveis","kind":"function"},{"id":"tmux.PaneCommandIs","name":"PaneCommandIs","slug":"tmux-panecommandis","kind":"function"},{"id":"tmux.PaneIDIs","name":"PaneIDIs","slug":"tmux-paneidis","kind":"function"},{"id":"tmux.PaneIndexIs","name":"PaneIndexIs","slug":"tmux-paneindexis","kind":"function"},{"id":"tmux.PaneSessionIDIs","name":"PaneSessionIDIs","slug":"tmux-panesessionidis","kind":"function"},{"id":"tmux.PaneTitleIs","name":"PaneTitleIs","slug":"tmux-panetitleis","kind":"function"},{"id":"tmux.PaneWindowIDIs","name":"PaneWindowIDIs","slug":"tmux-panewindowidis","kind":"function"},{"id":"tmux.PaneWindowIndexIs","name":"PaneWindowIndexIs","slug":"tmux-panewindowindexis","kind":"function"},{"id":"tmux.ParseClientLookup","name":"ParseClientLookup","slug":"tmux-parseclientlookup","kind":"function"},{"id":"tmux.ParsePaneLookup","name":"ParsePaneLookup","slug":"tmux-parsepanelookup","kind":"function"},{"id":"tmux.ParseSessionLookup","name":"ParseSessionLookup","slug":"tmux-parsesessionlookup","kind":"function"},{"id":"tmux.ParseWindowLookup","name":"ParseWindowLookup","slug":"tmux-parsewindowlookup","kind":"function"},{"id":"tmux.Ptr","name":"Ptr","slug":"tmux-ptr","kind":"function"},{"id":"tmux.SessionAttachedIs","name":"SessionAttachedIs","slug":"tmux-sessionattachedis","kind":"function"},{"id":"tmux.SessionIDIs","name":"SessionIDIs","slug":"tmux-sessionidis","kind":"function"},{"id":"tmux.SessionNameIs","name":"SessionNameIs","slug":"tmux-sessionnameis","kind":"function"},{"id":"tmuxq.Where","name":"Where","slug":"tmuxq-where","kind":"function"},{"id":"tmuxq.WhereSeq","name":"WhereSeq","slug":"tmuxq-whereseq","kind":"function"},{"id":"tmux.WindowActiveIs","name":"WindowActiveIs","slug":"tmux-windowactiveis","kind":"function"},{"id":"tmux.WindowIDIs","name":"WindowIDIs","slug":"tmux-windowidis","kind":"function"},{"id":"tmux.WindowIndexIs","name":"WindowIndexIs","slug":"tmux-windowindexis","kind":"function"},{"id":"tmux.WindowNameIs","name":"WindowNameIs","slug":"tmux-windownameis","kind":"function"},{"id":"tmux.WindowSessionIDIs","name":"WindowSessionIDIs","slug":"tmux-windowsessionidis","kind":"function"}],"queries-fields":[],"queries-operators":[],"queries-expressions":[],"snapshots":[{"id":"tmux.CapturePosition","name":"CapturePosition","slug":"tmux-captureposition","kind":"struct"},{"id":"tmux.Snapshot","name":"Snapshot","slug":"tmux-snapshot","kind":"struct"},{"id":"tmux.CaptureBoundary","name":"CaptureBoundary","slug":"tmux-captureboundary","kind":"constant"},{"id":"tmux.CaptureLine","name":"CaptureLine","slug":"tmux-captureline","kind":"function"}],"workspace":[{"id":"tmux.Ref","name":"Ref","slug":"tmux-ref","kind":"struct"},{"id":"tmux.Op","name":"Op","slug":"tmux-op","kind":"struct"},{"id":"tmux.Dispatch","name":"Dispatch","slug":"tmux-dispatch","kind":"struct"},{"id":"tmux.Sequential","name":"Sequential","slug":"tmux-sequential","kind":"struct"},{"id":"tmux.Folding","name":"Folding","slug":"tmux-folding","kind":"struct"},{"id":"tmux.OpStatus","name":"OpStatus","slug":"tmux-opstatus","kind":"struct"},{"id":"tmux.OpComplete","name":"OpComplete","slug":"tmux-opcomplete","kind":"constant"},{"id":"tmux.OpFailed","name":"OpFailed","slug":"tmux-opfailed","kind":"constant"},{"id":"tmux.OpIndeterminate","name":"OpIndeterminate","slug":"tmux-opindeterminate","kind":"constant"},{"id":"tmux.OpSkipped","name":"OpSkipped","slug":"tmux-opskipped","kind":"constant"}],"workspace-plan":[{"id":"tmux.Plan","name":"Plan","slug":"tmux-plan","kind":"struct"},{"id":"tmux.Planner","name":"Planner","slug":"tmux-planner","kind":"struct"},{"id":"workspace.Workspace","name":"Workspace","slug":"workspace-workspace","kind":"struct"},{"id":"tmux.NewPlan","name":"NewPlan","slug":"tmux-newplan","kind":"function"}],"workspace-steps":[],"workspace-targets":[],"workspace-session":[{"id":"tmux.SessionRef","name":"SessionRef","slug":"tmux-sessionref","kind":"function"}],"workspace-window":[{"id":"tmux.WindowRef","name":"WindowRef","slug":"tmux-windowref","kind":"function"}],"workspace-pane":[{"id":"tmux.PaneRef","name":"PaneRef","slug":"tmux-paneref","kind":"function"}],"workspace-functions":[{"id":"workspace.Build","name":"Build","slug":"workspace-build","kind":"function"},{"id":"workspace.BuildInto","name":"BuildInto","slug":"workspace-buildinto","kind":"function"},{"id":"workspace.Parse","name":"Parse","slug":"workspace-parse","kind":"function"}],"workspace-constants":[],"requests":[{"id":"tmux.DisplayMessageRequest","name":"DisplayMessageRequest","slug":"tmux-displaymessagerequest","kind":"struct"},{"id":"tmux.SubscriptionRequest","name":"SubscriptionRequest","slug":"tmux-subscriptionrequest","kind":"struct"},{"id":"tmux.SendKeysRequest","name":"SendKeysRequest","slug":"tmux-sendkeysrequest","kind":"struct"},{"id":"tmux.SendKeySequenceRequest","name":"SendKeySequenceRequest","slug":"tmux-sendkeysequencerequest","kind":"struct"},{"id":"tmux.ClearHistoryRequest","name":"ClearHistoryRequest","slug":"tmux-clearhistoryrequest","kind":"struct"},{"id":"tmux.CopyModeRequest","name":"CopyModeRequest","slug":"tmux-copymoderequest","kind":"struct"},{"id":"tmux.ChooseTreeRequest","name":"ChooseTreeRequest","slug":"tmux-choosetreerequest","kind":"struct"},{"id":"tmux.DisplayPopupRequest","name":"DisplayPopupRequest","slug":"tmux-displaypopuprequest","kind":"struct"},{"id":"tmux.PasteBufferRequest","name":"PasteBufferRequest","slug":"tmux-pastebufferrequest","kind":"struct"},{"id":"tmux.SetPlanOptionRequest","name":"SetPlanOptionRequest","slug":"tmux-setplanoptionrequest","kind":"struct"},{"id":"tmux.PromptHistoryRequest","name":"PromptHistoryRequest","slug":"tmux-prompthistoryrequest","kind":"struct"},{"id":"tmux.SetBufferRequest","name":"SetBufferRequest","slug":"tmux-setbufferrequest","kind":"struct"},{"id":"tmux.SaveBufferRequest","name":"SaveBufferRequest","slug":"tmux-savebufferrequest","kind":"struct"},{"id":"tmux.LoadBufferRequest","name":"LoadBufferRequest","slug":"tmux-loadbufferrequest","kind":"struct"},{"id":"tmux.ListBuffersRequest","name":"ListBuffersRequest","slug":"tmux-listbuffersrequest","kind":"struct"},{"id":"tmux.RunShellRequest","name":"RunShellRequest","slug":"tmux-runshellrequest","kind":"struct"},{"id":"tmux.WaitForRequest","name":"WaitForRequest","slug":"tmux-waitforrequest","kind":"struct"},{"id":"tmux.IfShellRequest","name":"IfShellRequest","slug":"tmux-ifshellrequest","kind":"struct"},{"id":"tmux.SourceFileRequest","name":"SourceFileRequest","slug":"tmux-sourcefilerequest","kind":"struct"},{"id":"tmux.ConfirmBeforeRequest","name":"ConfirmBeforeRequest","slug":"tmux-confirmbeforerequest","kind":"struct"},{"id":"tmux.CommandPromptRequest","name":"CommandPromptRequest","slug":"tmux-commandpromptrequest","kind":"struct"},{"id":"tmux.DisplayMenuRequest","name":"DisplayMenuRequest","slug":"tmux-displaymenurequest","kind":"struct"},{"id":"tmux.BindKeyRequest","name":"BindKeyRequest","slug":"tmux-bindkeyrequest","kind":"struct"},{"id":"tmux.UnbindKeyRequest","name":"UnbindKeyRequest","slug":"tmux-unbindkeyrequest","kind":"struct"},{"id":"tmux.ListKeysRequest","name":"ListKeysRequest","slug":"tmux-listkeysrequest","kind":"struct"},{"id":"tmux.ListCommandsRequest","name":"ListCommandsRequest","slug":"tmux-listcommandsrequest","kind":"struct"},{"id":"tmux.ShowMessagesRequest","name":"ShowMessagesRequest","slug":"tmux-showmessagesrequest","kind":"struct"},{"id":"tmux.SelectLayoutRequest","name":"SelectLayoutRequest","slug":"tmux-selectlayoutrequest","kind":"struct"},{"id":"tmux.RespawnRequest","name":"RespawnRequest","slug":"tmux-respawnrequest","kind":"struct"},{"id":"tmux.ErrInvalidCaptureRequest","name":"ErrInvalidCaptureRequest","slug":"tmux-errinvalidcapturerequest","kind":"attribute"},{"id":"tmux.ErrInvalidRequest","name":"ErrInvalidRequest","slug":"tmux-errinvalidrequest","kind":"attribute"}],"requests-server":[{"id":"tmux.ServerAccessRequest","name":"ServerAccessRequest","slug":"tmux-serveraccessrequest","kind":"struct"},{"id":"tmux.ErrInvalidServerCommandRequest","name":"ErrInvalidServerCommandRequest","slug":"tmux-errinvalidservercommandrequest","kind":"attribute"}],"requests-session":[{"id":"tmux.SessionKillRequest","name":"SessionKillRequest","slug":"tmux-sessionkillrequest","kind":"struct"},{"id":"tmux.AttachSessionRequest","name":"AttachSessionRequest","slug":"tmux-attachsessionrequest","kind":"struct"},{"id":"tmux.HasSessionRequest","name":"HasSessionRequest","slug":"tmux-hassessionrequest","kind":"struct"},{"id":"tmux.NewSessionRequest","name":"NewSessionRequest","slug":"tmux-newsessionrequest","kind":"struct"}],"requests-window":[{"id":"tmux.KillWindowRequest","name":"KillWindowRequest","slug":"tmux-killwindowrequest","kind":"struct"},{"id":"tmux.FindWindowRequest","name":"FindWindowRequest","slug":"tmux-findwindowrequest","kind":"struct"},{"id":"tmux.SelectWindowRequest","name":"SelectWindowRequest","slug":"tmux-selectwindowrequest","kind":"struct"},{"id":"tmux.NewWindowRequest","name":"NewWindowRequest","slug":"tmux-newwindowrequest","kind":"struct"},{"id":"tmux.LinkWindowRequest","name":"LinkWindowRequest","slug":"tmux-linkwindowrequest","kind":"struct"},{"id":"tmux.UnlinkWindowRequest","name":"UnlinkWindowRequest","slug":"tmux-unlinkwindowrequest","kind":"struct"},{"id":"tmux.MoveWindowRequest","name":"MoveWindowRequest","slug":"tmux-movewindowrequest","kind":"struct"},{"id":"tmux.SwapWindowRequest","name":"SwapWindowRequest","slug":"tmux-swapwindowrequest","kind":"struct"},{"id":"tmux.WindowSelectPaneRequest","name":"WindowSelectPaneRequest","slug":"tmux-windowselectpanerequest","kind":"struct"},{"id":"tmux.RotateWindowRequest","name":"RotateWindowRequest","slug":"tmux-rotatewindowrequest","kind":"struct"},{"id":"tmux.ResizeWindowRequest","name":"ResizeWindowRequest","slug":"tmux-resizewindowrequest","kind":"struct"}],"requests-pane":[{"id":"tmux.PaneDisplayMessageRequest","name":"PaneDisplayMessageRequest","slug":"tmux-panedisplaymessagerequest","kind":"struct"},{"id":"tmux.CapturePaneRequest","name":"CapturePaneRequest","slug":"tmux-capturepanerequest","kind":"struct"},{"id":"tmux.NewPaneRequest","name":"NewPaneRequest","slug":"tmux-newpanerequest","kind":"struct"},{"id":"tmux.SplitPaneRequest","name":"SplitPaneRequest","slug":"tmux-splitpanerequest","kind":"struct"},{"id":"tmux.ResizePaneRequest","name":"ResizePaneRequest","slug":"tmux-resizepanerequest","kind":"struct"},{"id":"tmux.DisplayPanesRequest","name":"DisplayPanesRequest","slug":"tmux-displaypanesrequest","kind":"struct"},{"id":"tmux.PipePaneRequest","name":"PipePaneRequest","slug":"tmux-pipepanerequest","kind":"struct"},{"id":"tmux.MovePaneRequest","name":"MovePaneRequest","slug":"tmux-movepanerequest","kind":"struct"},{"id":"tmux.JoinPaneRequest","name":"JoinPaneRequest","slug":"tmux-joinpanerequest","kind":"struct"},{"id":"tmux.BreakPaneRequest","name":"BreakPaneRequest","slug":"tmux-breakpanerequest","kind":"struct"},{"id":"tmux.SwapPaneRequest","name":"SwapPaneRequest","slug":"tmux-swappanerequest","kind":"struct"},{"id":"tmux.PaneSelectRequest","name":"PaneSelectRequest","slug":"tmux-paneselectrequest","kind":"struct"},{"id":"tmux.LastPaneRequest","name":"LastPaneRequest","slug":"tmux-lastpanerequest","kind":"struct"}],"requests-client":[{"id":"tmux.RefreshClientRequest","name":"RefreshClientRequest","slug":"tmux-refreshclientrequest","kind":"struct"},{"id":"tmux.DetachClientRequest","name":"DetachClientRequest","slug":"tmux-detachclientrequest","kind":"struct"},{"id":"tmux.DetachAllClientsRequest","name":"DetachAllClientsRequest","slug":"tmux-detachallclientsrequest","kind":"struct"}],"errors":[{"id":"tmux.ColorError","name":"ColorError","slug":"tmux-colorerror","kind":"struct"},{"id":"tmux.CommandError","name":"CommandError","slug":"tmux-commanderror","kind":"struct"},{"id":"tmux.ComplexOptionDecodeError","name":"ComplexOptionDecodeError","slug":"tmux-complexoptiondecodeerror","kind":"struct"},{"id":"tmux.ControlNotificationError","name":"ControlNotificationError","slug":"tmux-controlnotificationerror","kind":"struct"},{"id":"tmux.ControlNotificationOverflowError","name":"ControlNotificationOverflowError","slug":"tmux-controlnotificationoverflowerror","kind":"struct"},{"id":"tmux.ControlProtocolError","name":"ControlProtocolError","slug":"tmux-controlprotocolerror","kind":"struct"},{"id":"tmux.EnvironmentNameError","name":"EnvironmentNameError","slug":"tmux-environmentnameerror","kind":"struct"},{"id":"tmux.EnvironmentValueError","name":"EnvironmentValueError","slug":"tmux-environmentvalueerror","kind":"struct"},{"id":"tmux.EnvironmentDecodeError","name":"EnvironmentDecodeError","slug":"tmux-environmentdecodeerror","kind":"struct"},{"id":"tmux.FormatDecodeError","name":"FormatDecodeError","slug":"tmux-formatdecodeerror","kind":"struct"},{"id":"tmux.FromEnvError","name":"FromEnvError","slug":"tmux-fromenverror","kind":"struct"},{"id":"tmux.OptionDecodeError","name":"OptionDecodeError","slug":"tmux-optiondecodeerror","kind":"struct"},{"id":"tmux.OptionValueError","name":"OptionValueError","slug":"tmux-optionvalueerror","kind":"struct"},{"id":"tmux.OptionError","name":"OptionError","slug":"tmux-optionerror","kind":"struct"},{"id":"tmux.CaptureRequestError","name":"CaptureRequestError","slug":"tmux-capturerequesterror","kind":"struct"},{"id":"tmux.PlanError","name":"PlanError","slug":"tmux-planerror","kind":"struct"},{"id":"tmux.VersionQueryError","name":"VersionQueryError","slug":"tmux-versionqueryerror","kind":"struct"},{"id":"tmux.VersionTooLowError","name":"VersionTooLowError","slug":"tmux-versiontoolowerror","kind":"struct"},{"id":"tmux.SnapshotDecodeError","name":"SnapshotDecodeError","slug":"tmux-snapshotdecodeerror","kind":"struct"},{"id":"tmux.SnapshotLookupError","name":"SnapshotLookupError","slug":"tmux-snapshotlookuperror","kind":"struct"},{"id":"tmux.TargetError","name":"TargetError","slug":"tmux-targeterror","kind":"struct"},{"id":"tmux.MissingTargetError","name":"MissingTargetError","slug":"tmux-missingtargeterror","kind":"struct"},{"id":"tmux.VersionError","name":"VersionError","slug":"tmux-versionerror","kind":"struct"},{"id":"tmux.ErrAmbiguousOption","name":"ErrAmbiguousOption","slug":"tmux-errambiguousoption","kind":"attribute"},{"id":"tmux.ErrCommand","name":"ErrCommand","slug":"tmux-errcommand","kind":"attribute"},{"id":"tmux.ErrConnectionRequiresProcess","name":"ErrConnectionRequiresProcess","slug":"tmux-errconnectionrequiresprocess","kind":"attribute"},{"id":"tmux.ErrControlClosed","name":"ErrControlClosed","slug":"tmux-errcontrolclosed","kind":"attribute"},{"id":"tmux.ErrControlNotificationOverflow","name":"ErrControlNotificationOverflow","slug":"tmux-errcontrolnotificationoverflow","kind":"attribute"},{"id":"tmux.ErrControlProtocol","name":"ErrControlProtocol","slug":"tmux-errcontrolprotocol","kind":"attribute"},{"id":"tmux.ErrControlReplyCount","name":"ErrControlReplyCount","slug":"tmux-errcontrolreplycount","kind":"attribute"},{"id":"tmux.ErrControlStreamLost","name":"ErrControlStreamLost","slug":"tmux-errcontrolstreamlost","kind":"attribute"},{"id":"tmux.ErrDaemonReplaced","name":"ErrDaemonReplaced","slug":"tmux-errdaemonreplaced","kind":"attribute"},{"id":"tmux.ErrDuplicateSparseIndex","name":"ErrDuplicateSparseIndex","slug":"tmux-errduplicatesparseindex","kind":"attribute"},{"id":"tmux.ErrInvalidCommandOutput","name":"ErrInvalidCommandOutput","slug":"tmux-errinvalidcommandoutput","kind":"attribute"},{"id":"tmux.ErrInvalidEnvironmentName","name":"ErrInvalidEnvironmentName","slug":"tmux-errinvalidenvironmentname","kind":"attribute"},{"id":"tmux.ErrInvalidEnvironmentValue","name":"ErrInvalidEnvironmentValue","slug":"tmux-errinvalidenvironmentvalue","kind":"attribute"},{"id":"tmux.ErrInvalidFilter","name":"ErrInvalidFilter","slug":"tmux-errinvalidfilter","kind":"attribute"},{"id":"tmux.ErrInvalidOption","name":"ErrInvalidOption","slug":"tmux-errinvalidoption","kind":"attribute"},{"id":"tmux.ErrInvalidOptionValue","name":"ErrInvalidOptionValue","slug":"tmux-errinvalidoptionvalue","kind":"attribute"},{"id":"tmux.ErrInvalidSparseIndex","name":"ErrInvalidSparseIndex","slug":"tmux-errinvalidsparseindex","kind":"attribute"},{"id":"tmux.ErrInvalidTarget","name":"ErrInvalidTarget","slug":"tmux-errinvalidtarget","kind":"attribute"},{"id":"tmux.ErrInvalidVersion","name":"ErrInvalidVersion","slug":"tmux-errinvalidversion","kind":"attribute"},{"id":"workspace.ErrInvalidWorkspace","name":"ErrInvalidWorkspace","slug":"workspace-errinvalidworkspace","kind":"attribute"},{"id":"tmux.ErrMalformedComplexOption","name":"ErrMalformedComplexOption","slug":"tmux-errmalformedcomplexoption","kind":"attribute"},{"id":"tmux.ErrMalformedControlNotification","name":"ErrMalformedControlNotification","slug":"tmux-errmalformedcontrolnotification","kind":"attribute"},{"id":"tmux.ErrMalformedEnvironment","name":"ErrMalformedEnvironment","slug":"tmux-errmalformedenvironment","kind":"attribute"},{"id":"tmux.ErrMalformedFormatOutput","name":"ErrMalformedFormatOutput","slug":"tmux-errmalformedformatoutput","kind":"attribute"},{"id":"tmux.ErrMalformedOptionOutput","name":"ErrMalformedOptionOutput","slug":"tmux-errmalformedoptionoutput","kind":"attribute"},{"id":"tmux.ErrMalformedSnapshot","name":"ErrMalformedSnapshot","slug":"tmux-errmalformedsnapshot","kind":"attribute"},{"id":"tmux.ErrMissingSubcommand","name":"ErrMissingSubcommand","slug":"tmux-errmissingsubcommand","kind":"attribute"},{"id":"tmux.ErrMissingTarget","name":"ErrMissingTarget","slug":"tmux-errmissingtarget","kind":"attribute"},{"id":"tmuxq.ErrMultipleMatches","name":"ErrMultipleMatches","slug":"tmuxq-errmultiplematches","kind":"attribute"},{"id":"tmuxq.ErrNoMatch","name":"ErrNoMatch","slug":"tmuxq-errnomatch","kind":"attribute"},{"id":"tmux.ErrNotFound","name":"ErrNotFound","slug":"tmux-errnotfound","kind":"attribute"},{"id":"tmux.ErrNotInsideTmux","name":"ErrNotInsideTmux","slug":"tmux-errnotinsidetmux","kind":"attribute"},{"id":"tmux.ErrOption","name":"ErrOption","slug":"tmux-erroption","kind":"attribute"},{"id":"tmux.ErrOptionTarget","name":"ErrOptionTarget","slug":"tmux-erroptiontarget","kind":"attribute"},{"id":"tmux.ErrOutcomeUnknown","name":"ErrOutcomeUnknown","slug":"tmux-erroutcomeunknown","kind":"attribute"},{"id":"tmux.ErrOutcomeUnrecorded","name":"ErrOutcomeUnrecorded","slug":"tmux-erroutcomeunrecorded","kind":"attribute"},{"id":"tmux.ErrPlan","name":"ErrPlan","slug":"tmux-errplan","kind":"attribute"},{"id":"tmux.ErrPollCondition","name":"ErrPollCondition","slug":"tmux-errpollcondition","kind":"attribute"},{"id":"tmux.ErrSnapshotAmbiguous","name":"ErrSnapshotAmbiguous","slug":"tmux-errsnapshotambiguous","kind":"attribute"},{"id":"tmux.ErrUnknownColor","name":"ErrUnknownColor","slug":"tmux-errunknowncolor","kind":"attribute"},{"id":"tmux.ErrUnknownControlNotification","name":"ErrUnknownControlNotification","slug":"tmux-errunknowncontrolnotification","kind":"attribute"},{"id":"tmux.ErrUnknownOption","name":"ErrUnknownOption","slug":"tmux-errunknownoption","kind":"attribute"},{"id":"tmux.ErrVersionQuery","name":"ErrVersionQuery","slug":"tmux-errversionquery","kind":"attribute"},{"id":"tmux.ErrVersionTooLow","name":"ErrVersionTooLow","slug":"tmux-errversiontoolow","kind":"attribute"}],"errors-server":[{"id":"tmux.ServerCommandRequestError","name":"ServerCommandRequestError","slug":"tmux-servercommandrequesterror","kind":"struct"},{"id":"tmux.ErrInvalidServer","name":"ErrInvalidServer","slug":"tmux-errinvalidserver","kind":"attribute"},{"id":"tmux.ErrInvalidServerOptions","name":"ErrInvalidServerOptions","slug":"tmux-errinvalidserveroptions","kind":"attribute"},{"id":"tmux.ErrNoServer","name":"ErrNoServer","slug":"tmux-errnoserver","kind":"attribute"}],"errors-session":[{"id":"tmux.ErrSessionExists","name":"ErrSessionExists","slug":"tmux-errsessionexists","kind":"attribute"}],"errors-window":[],"errors-pane":[{"id":"tmux.ErrPaneObservationLost","name":"ErrPaneObservationLost","slug":"tmux-errpaneobservationlost","kind":"attribute"}],"constants":[{"id":"tmux.ColorMode","name":"ColorMode","slug":"tmux-colormode","kind":"struct"},{"id":"tmux.CommandResult","name":"CommandResult","slug":"tmux-commandresult","kind":"struct"},{"id":"tmux.TerminalOverrideValueKind","name":"TerminalOverrideValueKind","slug":"tmux-terminaloverridevaluekind","kind":"struct"},{"id":"tmux.ConnectionOptions","name":"ConnectionOptions","slug":"tmux-connectionoptions","kind":"struct"},{"id":"tmux.ControlCommandResult","name":"ControlCommandResult","slug":"tmux-controlcommandresult","kind":"struct"},{"id":"tmux.SetEnvironmentOptions","name":"SetEnvironmentOptions","slug":"tmux-setenvironmentoptions","kind":"struct"},{"id":"tmux.SetHooksOptions","name":"SetHooksOptions","slug":"tmux-sethooksoptions","kind":"struct"},{"id":"tmux.SetHooksResult","name":"SetHooksResult","slug":"tmux-sethooksresult","kind":"struct"},{"id":"tmux.NotificationOptions","name":"NotificationOptions","slug":"tmux-notificationoptions","kind":"struct"},{"id":"tmux.ActivityAction","name":"ActivityAction","slug":"tmux-activityaction","kind":"struct"},{"id":"tmux.BellAction","name":"BellAction","slug":"tmux-bellaction","kind":"struct"},{"id":"tmux.ClockModeStyle","name":"ClockModeStyle","slug":"tmux-clockmodestyle","kind":"struct"},{"id":"tmux.CursorStyle","name":"CursorStyle","slug":"tmux-cursorstyle","kind":"struct"},{"id":"tmux.PromptCommandCursorStyle","name":"PromptCommandCursorStyle","slug":"tmux-promptcommandcursorstyle","kind":"struct"},{"id":"tmux.PromptCursorStyle","name":"PromptCursorStyle","slug":"tmux-promptcursorstyle","kind":"struct"},{"id":"tmux.SilenceAction","name":"SilenceAction","slug":"tmux-silenceaction","kind":"struct"},{"id":"tmux.ControlNotificationKind","name":"ControlNotificationKind","slug":"tmux-controlnotificationkind","kind":"struct"},{"id":"tmux.SetOptionOptions","name":"SetOptionOptions","slug":"tmux-setoptionoptions","kind":"struct"},{"id":"tmux.UnsetOptionOptions","name":"UnsetOptionOptions","slug":"tmux-unsetoptionoptions","kind":"struct"},{"id":"tmux.SetArrayResult","name":"SetArrayResult","slug":"tmux-setarrayresult","kind":"struct"},{"id":"tmux.PlanResult","name":"PlanResult","slug":"tmux-planresult","kind":"struct"},{"id":"tmux.OpResult","name":"OpResult","slug":"tmux-opresult","kind":"struct"},{"id":"tmux.LoadBufferFromOptions","name":"LoadBufferFromOptions","slug":"tmux-loadbufferfromoptions","kind":"struct"},{"id":"tmux.SaveBufferToOptions","name":"SaveBufferToOptions","slug":"tmux-savebuffertooptions","kind":"struct"},{"id":"tmux.WaitForMode","name":"WaitForMode","slug":"tmux-waitformode","kind":"struct"},{"id":"tmux.RunOptions","name":"RunOptions","slug":"tmux-runoptions","kind":"struct"},{"id":"tmux.RunResult","name":"RunResult","slug":"tmux-runresult","kind":"struct"},{"id":"tmux.WarningKind","name":"WarningKind","slug":"tmux-warningkind","kind":"struct"},{"id":"tmux.ActivityActionAny","name":"ActivityActionAny","slug":"tmux-activityactionany","kind":"constant"},{"id":"tmux.ActivityActionCurrent","name":"ActivityActionCurrent","slug":"tmux-activityactioncurrent","kind":"constant"},{"id":"tmux.ActivityActionNone","name":"ActivityActionNone","slug":"tmux-activityactionnone","kind":"constant"},{"id":"tmux.ActivityActionOther","name":"ActivityActionOther","slug":"tmux-activityactionother","kind":"constant"},{"id":"tmux.BellActionAny","name":"BellActionAny","slug":"tmux-bellactionany","kind":"constant"},{"id":"tmux.BellActionCurrent","name":"BellActionCurrent","slug":"tmux-bellactioncurrent","kind":"constant"},{"id":"tmux.BellActionNone","name":"BellActionNone","slug":"tmux-bellactionnone","kind":"constant"},{"id":"tmux.BellActionOther","name":"BellActionOther","slug":"tmux-bellactionother","kind":"constant"},{"id":"tmux.ClockModeStyle12","name":"ClockModeStyle12","slug":"tmux-clockmodestyle12","kind":"constant"},{"id":"tmux.ClockModeStyle12WithSeconds","name":"ClockModeStyle12WithSeconds","slug":"tmux-clockmodestyle12withseconds","kind":"constant"},{"id":"tmux.ClockModeStyle24","name":"ClockModeStyle24","slug":"tmux-clockmodestyle24","kind":"constant"},{"id":"tmux.ClockModeStyle24WithSeconds","name":"ClockModeStyle24WithSeconds","slug":"tmux-clockmodestyle24withseconds","kind":"constant"},{"id":"tmux.Color256","name":"Color256","slug":"tmux-color256","kind":"constant"},{"id":"tmux.ColorDefault","name":"ColorDefault","slug":"tmux-colordefault","kind":"constant"},{"id":"tmux.ControlNotificationClientDetached","name":"ControlNotificationClientDetached","slug":"tmux-controlnotificationclientdetached","kind":"constant"},{"id":"tmux.ControlNotificationClientSessionChanged","name":"ControlNotificationClientSessionChanged","slug":"tmux-controlnotificationclientsessionchanged","kind":"constant"},{"id":"tmux.ControlNotificationConfigError","name":"ControlNotificationConfigError","slug":"tmux-controlnotificationconfigerror","kind":"constant"},{"id":"tmux.ControlNotificationContinue","name":"ControlNotificationContinue","slug":"tmux-controlnotificationcontinue","kind":"constant"},{"id":"tmux.ControlNotificationExit","name":"ControlNotificationExit","slug":"tmux-controlnotificationexit","kind":"constant"},{"id":"tmux.ControlNotificationExtendedOutput","name":"ControlNotificationExtendedOutput","slug":"tmux-controlnotificationextendedoutput","kind":"constant"},{"id":"tmux.ControlNotificationLayoutChange","name":"ControlNotificationLayoutChange","slug":"tmux-controlnotificationlayoutchange","kind":"constant"},{"id":"tmux.ControlNotificationMessage","name":"ControlNotificationMessage","slug":"tmux-controlnotificationmessage","kind":"constant"},{"id":"tmux.ControlNotificationOutput","name":"ControlNotificationOutput","slug":"tmux-controlnotificationoutput","kind":"constant"},{"id":"tmux.ControlNotificationPaneModeChanged","name":"ControlNotificationPaneModeChanged","slug":"tmux-controlnotificationpanemodechanged","kind":"constant"},{"id":"tmux.ControlNotificationPasteBufferChanged","name":"ControlNotificationPasteBufferChanged","slug":"tmux-controlnotificationpastebufferchanged","kind":"constant"},{"id":"tmux.ControlNotificationPasteBufferDeleted","name":"ControlNotificationPasteBufferDeleted","slug":"tmux-controlnotificationpastebufferdeleted","kind":"constant"},{"id":"tmux.ControlNotificationPause","name":"ControlNotificationPause","slug":"tmux-controlnotificationpause","kind":"constant"},{"id":"tmux.ControlNotificationSessionChanged","name":"ControlNotificationSessionChanged","slug":"tmux-controlnotificationsessionchanged","kind":"constant"},{"id":"tmux.ControlNotificationSessionRenamed","name":"ControlNotificationSessionRenamed","slug":"tmux-controlnotificationsessionrenamed","kind":"constant"},{"id":"tmux.ControlNotificationSessionsChanged","name":"ControlNotificationSessionsChanged","slug":"tmux-controlnotificationsessionschanged","kind":"constant"},{"id":"tmux.ControlNotificationSessionWindowChanged","name":"ControlNotificationSessionWindowChanged","slug":"tmux-controlnotificationsessionwindowchanged","kind":"constant"},{"id":"tmux.ControlNotificationSubscriptionChanged","name":"ControlNotificationSubscriptionChanged","slug":"tmux-controlnotificationsubscriptionchanged","kind":"constant"},{"id":"tmux.ControlNotificationUnlinkedWindowAdd","name":"ControlNotificationUnlinkedWindowAdd","slug":"tmux-controlnotificationunlinkedwindowadd","kind":"constant"},{"id":"tmux.ControlNotificationUnlinkedWindowClose","name":"ControlNotificationUnlinkedWindowClose","slug":"tmux-controlnotificationunlinkedwindowclose","kind":"constant"},{"id":"tmux.ControlNotificationUnlinkedWindowRenamed","name":"ControlNotificationUnlinkedWindowRenamed","slug":"tmux-controlnotificationunlinkedwindowrenamed","kind":"constant"},{"id":"tmux.ControlNotificationWindowAdd","name":"ControlNotificationWindowAdd","slug":"tmux-controlnotificationwindowadd","kind":"constant"},{"id":"tmux.ControlNotificationWindowClose","name":"ControlNotificationWindowClose","slug":"tmux-controlnotificationwindowclose","kind":"constant"},{"id":"tmux.ControlNotificationWindowPaneChanged","name":"ControlNotificationWindowPaneChanged","slug":"tmux-controlnotificationwindowpanechanged","kind":"constant"},{"id":"tmux.ControlNotificationWindowRenamed","name":"ControlNotificationWindowRenamed","slug":"tmux-controlnotificationwindowrenamed","kind":"constant"},{"id":"tmux.CursorStyleBar","name":"CursorStyleBar","slug":"tmux-cursorstylebar","kind":"constant"},{"id":"tmux.CursorStyleBlinkingBar","name":"CursorStyleBlinkingBar","slug":"tmux-cursorstyleblinkingbar","kind":"constant"},{"id":"tmux.CursorStyleBlinkingBlock","name":"CursorStyleBlinkingBlock","slug":"tmux-cursorstyleblinkingblock","kind":"constant"},{"id":"tmux.CursorStyleBlinkingUnderline","name":"CursorStyleBlinkingUnderline","slug":"tmux-cursorstyleblinkingunderline","kind":"constant"},{"id":"tmux.CursorStyleBlock","name":"CursorStyleBlock","slug":"tmux-cursorstyleblock","kind":"constant"},{"id":"tmux.CursorStyleDefault","name":"CursorStyleDefault","slug":"tmux-cursorstyledefault","kind":"constant"},{"id":"tmux.CursorStyleUnderline","name":"CursorStyleUnderline","slug":"tmux-cursorstyleunderline","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBar","name":"PromptCommandCursorStyleBar","slug":"tmux-promptcommandcursorstylebar","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBlinkingBar","name":"PromptCommandCursorStyleBlinkingBar","slug":"tmux-promptcommandcursorstyleblinkingbar","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBlinkingBlock","name":"PromptCommandCursorStyleBlinkingBlock","slug":"tmux-promptcommandcursorstyleblinkingblock","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBlinkingUnderline","name":"PromptCommandCursorStyleBlinkingUnderline","slug":"tmux-promptcommandcursorstyleblinkingunderline","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleBlock","name":"PromptCommandCursorStyleBlock","slug":"tmux-promptcommandcursorstyleblock","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleDefault","name":"PromptCommandCursorStyleDefault","slug":"tmux-promptcommandcursorstyledefault","kind":"constant"},{"id":"tmux.PromptCommandCursorStyleUnderline","name":"PromptCommandCursorStyleUnderline","slug":"tmux-promptcommandcursorstyleunderline","kind":"constant"},{"id":"tmux.PromptCursorStyleBar","name":"PromptCursorStyleBar","slug":"tmux-promptcursorstylebar","kind":"constant"},{"id":"tmux.PromptCursorStyleBlinkingBar","name":"PromptCursorStyleBlinkingBar","slug":"tmux-promptcursorstyleblinkingbar","kind":"constant"},{"id":"tmux.PromptCursorStyleBlinkingBlock","name":"PromptCursorStyleBlinkingBlock","slug":"tmux-promptcursorstyleblinkingblock","kind":"constant"},{"id":"tmux.PromptCursorStyleBlinkingUnderline","name":"PromptCursorStyleBlinkingUnderline","slug":"tmux-promptcursorstyleblinkingunderline","kind":"constant"},{"id":"tmux.PromptCursorStyleBlock","name":"PromptCursorStyleBlock","slug":"tmux-promptcursorstyleblock","kind":"constant"},{"id":"tmux.PromptCursorStyleDefault","name":"PromptCursorStyleDefault","slug":"tmux-promptcursorstyledefault","kind":"constant"},{"id":"tmux.PromptCursorStyleUnderline","name":"PromptCursorStyleUnderline","slug":"tmux-promptcursorstyleunderline","kind":"constant"},{"id":"tmux.SilenceActionAny","name":"SilenceActionAny","slug":"tmux-silenceactionany","kind":"constant"},{"id":"tmux.SilenceActionCurrent","name":"SilenceActionCurrent","slug":"tmux-silenceactioncurrent","kind":"constant"},{"id":"tmux.SilenceActionNone","name":"SilenceActionNone","slug":"tmux-silenceactionnone","kind":"constant"},{"id":"tmux.SilenceActionOther","name":"SilenceActionOther","slug":"tmux-silenceactionother","kind":"constant"},{"id":"tmux.TerminalOverrideValueFlag","name":"TerminalOverrideValueFlag","slug":"tmux-terminaloverridevalueflag","kind":"constant"},{"id":"tmux.TerminalOverrideValueInteger","name":"TerminalOverrideValueInteger","slug":"tmux-terminaloverridevalueinteger","kind":"constant"},{"id":"tmux.TerminalOverrideValueText","name":"TerminalOverrideValueText","slug":"tmux-terminaloverridevaluetext","kind":"constant"},{"id":"tmux.WaitForModeLock","name":"WaitForModeLock","slug":"tmux-waitformodelock","kind":"constant"},{"id":"tmux.WaitForModeSignal","name":"WaitForModeSignal","slug":"tmux-waitformodesignal","kind":"constant"},{"id":"tmux.WaitForModeUnlock","name":"WaitForModeUnlock","slug":"tmux-waitformodeunlock","kind":"constant"},{"id":"tmux.WaitForModeWait","name":"WaitForModeWait","slug":"tmux-waitformodewait","kind":"constant"},{"id":"tmux.WarningCommandStderr","name":"WarningCommandStderr","slug":"tmux-warningcommandstderr","kind":"constant"},{"id":"tmux.WarningUnsupportedFeature","name":"WarningUnsupportedFeature","slug":"tmux-warningunsupportedfeature","kind":"constant"}],"constants-server":[{"id":"tmux.ServerOptions","name":"ServerOptions","slug":"tmux-serveroptions","kind":"struct"}],"constants-session":[{"id":"tmux.AttachSessionOptions","name":"AttachSessionOptions","slug":"tmux-attachsessionoptions","kind":"struct"}],"constants-window":[{"id":"tmux.WindowSwapResult","name":"WindowSwapResult","slug":"tmux-windowswapresult","kind":"struct"}],"constants-pane":[{"id":"tmux.PaneSwapResult","name":"PaneSwapResult","slug":"tmux-paneswapresult","kind":"struct"},{"id":"tmux.PaneMarkMode","name":"PaneMarkMode","slug":"tmux-panemarkmode","kind":"struct"},{"id":"tmux.PaneInputMode","name":"PaneInputMode","slug":"tmux-paneinputmode","kind":"struct"},{"id":"tmux.PaneInputDisable","name":"PaneInputDisable","slug":"tmux-paneinputdisable","kind":"constant"},{"id":"tmux.PaneInputEnable","name":"PaneInputEnable","slug":"tmux-paneinputenable","kind":"constant"},{"id":"tmux.PaneInputUnchanged","name":"PaneInputUnchanged","slug":"tmux-paneinputunchanged","kind":"constant"},{"id":"tmux.PaneMarkClear","name":"PaneMarkClear","slug":"tmux-panemarkclear","kind":"constant"},{"id":"tmux.PaneMarkSet","name":"PaneMarkSet","slug":"tmux-panemarkset","kind":"constant"},{"id":"tmux.PaneMarkUnchanged","name":"PaneMarkUnchanged","slug":"tmux-panemarkunchanged","kind":"constant"}],"constants-client":[],"runtime":[],"async":[],"mcp":[{"id":"mcp.Instance","name":"Instance","slug":"mcp-instance","kind":"struct"},{"id":"mcp.ServerSession","name":"ServerSession","slug":"mcp-serversession","kind":"struct"}],"mcp-functions":[{"id":"mcp.AdvertisedTools","name":"AdvertisedTools","slug":"mcp-advertisedtools","kind":"function"},{"id":"mcp.AdvertisedToolsFor","name":"AdvertisedToolsFor","slug":"mcp-advertisedtoolsfor","kind":"function"},{"id":"mcp.AssumeResponseCommit","name":"AssumeResponseCommit","slug":"mcp-assumeresponsecommit","kind":"function"},{"id":"mcp.HandshakeOrdered","name":"HandshakeOrdered","slug":"mcp-handshakeordered","kind":"function"},{"id":"mcp.MaterializeMinimalConfig","name":"MaterializeMinimalConfig","slug":"mcp-materializeminimalconfig","kind":"function"},{"id":"mcp.NewServer","name":"NewServer","slug":"mcp-newserver","kind":"function"},{"id":"mcp.Run","name":"Run","slug":"mcp-run","kind":"function"},{"id":"mcp.RunDefaultMinimal","name":"RunDefaultMinimal","slug":"mcp-rundefaultminimal","kind":"function"},{"id":"mcp.ToolDetails","name":"ToolDetails","slug":"mcp-tooldetails","kind":"function"}],"mcp-constants":[{"id":"mcp.AuditEnvironmentVariable","name":"AuditEnvironmentVariable","slug":"mcp-auditenvironmentvariable","kind":"constant"},{"id":"mcp.BinaryEnvironmentVariable","name":"BinaryEnvironmentVariable","slug":"mcp-binaryenvironmentvariable","kind":"constant"},{"id":"mcp.CapabilitiesResourceURI","name":"CapabilitiesResourceURI","slug":"mcp-capabilitiesresourceuri","kind":"constant"},{"id":"mcp.CapabilityMetaKey","name":"CapabilityMetaKey","slug":"mcp-capabilitymetakey","kind":"constant"},{"id":"mcp.ErrInstanceClosed","name":"ErrInstanceClosed","slug":"mcp-errinstanceclosed","kind":"attribute"},{"id":"mcp.ErrRequestCapacity","name":"ErrRequestCapacity","slug":"mcp-errrequestcapacity","kind":"attribute"},{"id":"mcp.ErrResponseCommitUnknown","name":"ErrResponseCommitUnknown","slug":"mcp-errresponsecommitunknown","kind":"attribute"},{"id":"mcp.ErrRuntimeTargetBound","name":"ErrRuntimeTargetBound","slug":"mcp-errruntimetargetbound","kind":"attribute"},{"id":"mcp.ExcludeToolsEnvironmentVariable","name":"ExcludeToolsEnvironmentVariable","slug":"mcp-excludetoolsenvironmentvariable","kind":"constant"},{"id":"mcp.RecipeToolEnvironmentVariable","name":"RecipeToolEnvironmentVariable","slug":"mcp-recipetoolenvironmentvariable","kind":"constant"},{"id":"mcp.SafetyEnvironmentVariable","name":"SafetyEnvironmentVariable","slug":"mcp-safetyenvironmentvariable","kind":"constant"},{"id":"mcp.SocketEnvironmentVariable","name":"SocketEnvironmentVariable","slug":"mcp-socketenvironmentvariable","kind":"constant"},{"id":"mcp.SocketPathEnvironmentVariable","name":"SocketPathEnvironmentVariable","slug":"mcp-socketpathenvironmentvariable","kind":"constant"},{"id":"mcp.TmuxConfigEnvironmentVariable","name":"TmuxConfigEnvironmentVariable","slug":"mcp-tmuxconfigenvironmentvariable","kind":"constant"},{"id":"mcp.ToolsEnvironmentVariable","name":"ToolsEnvironmentVariable","slug":"mcp-toolsenvironmentvariable","kind":"constant"},{"id":"mcp.ToolsetsEnvironmentVariable","name":"ToolsetsEnvironmentVariable","slug":"mcp-toolsetsenvironmentvariable","kind":"constant"},{"id":"mcp.Version","name":"Version","slug":"mcp-version","kind":"attribute"},{"id":"mcp.WaitCeilingEnvironmentVariable","name":"WaitCeilingEnvironmentVariable","slug":"mcp-waitceilingenvironmentvariable","kind":"constant"}],"testing":[{"id":"tmuxtest.ControlMode","name":"ControlMode","slug":"tmuxtest-controlmode","kind":"struct"},{"id":"tmuxtest.ServerOptions","name":"ServerOptions","slug":"tmuxtest-serveroptions","kind":"struct"},{"id":"tmuxtest.PTYProcess","name":"PTYProcess","slug":"tmuxtest-ptyprocess","kind":"struct"},{"id":"tmuxtest.ScriptedCommand","name":"ScriptedCommand","slug":"tmuxtest-scriptedcommand","kind":"struct"},{"id":"tmux.MaximumTestedVersion","name":"MaximumTestedVersion","slug":"tmux-maximumtestedversion","kind":"constant"},{"id":"tmuxtest.ShellPrompt","name":"ShellPrompt","slug":"tmuxtest-shellprompt","kind":"constant"},{"id":"tmuxtest.SuiteRootTagVariable","name":"SuiteRootTagVariable","slug":"tmuxtest-suiteroottagvariable","kind":"constant"},{"id":"tmuxtest.TemporaryNamePrefix","name":"TemporaryNamePrefix","slug":"tmuxtest-temporarynameprefix","kind":"constant"},{"id":"tmuxtest.Main","name":"Main","slug":"tmuxtest-main","kind":"function"},{"id":"tmuxtest.NewControlMode","name":"NewControlMode","slug":"tmuxtest-newcontrolmode","kind":"function"},{"id":"tmuxtest.NewServer","name":"NewServer","slug":"tmuxtest-newserver","kind":"function"},{"id":"tmuxtest.NewServerWithOptions","name":"NewServerWithOptions","slug":"tmuxtest-newserverwithoptions","kind":"function"},{"id":"tmuxtest.NewSession","name":"NewSession","slug":"tmuxtest-newsession","kind":"function"},{"id":"tmuxtest.NewWindow","name":"NewWindow","slug":"tmuxtest-newwindow","kind":"function"},{"id":"tmuxtest.RunInPane","name":"RunInPane","slug":"tmuxtest-runinpane","kind":"function"},{"id":"tmuxtest.Screen","name":"Screen","slug":"tmuxtest-screen","kind":"function"},{"id":"tmuxtest.ScriptedTmux","name":"ScriptedTmux","slug":"tmuxtest-scriptedtmux","kind":"function"},{"id":"tmuxtest.StartPTYProcess","name":"StartPTYProcess","slug":"tmuxtest-startptyprocess","kind":"function"},{"id":"tmuxtest.Type","name":"Type","slug":"tmuxtest-type","kind":"function"},{"id":"tmuxtest.TypeAndWait","name":"TypeAndWait","slug":"tmuxtest-typeandwait","kind":"function"},{"id":"tmuxtest.WaitFor","name":"WaitFor","slug":"tmuxtest-waitfor","kind":"function"},{"id":"tmuxtest.WaitForLine","name":"WaitForLine","slug":"tmuxtest-waitforline","kind":"function"},{"id":"tmuxtest.WaitForScreen","name":"WaitForScreen","slug":"tmuxtest-waitforscreen","kind":"function"},{"id":"tmuxtest.WaitForShellReady","name":"WaitForShellReady","slug":"tmuxtest-waitforshellready","kind":"function"},{"id":"tmuxtest.WaitForText","name":"WaitForText","slug":"tmuxtest-waitfortext","kind":"function"}],"internal":[],"internal-commands":[],"internal-options":[]},"placement":{"tmux.NewServerFromEnv":"server","tmux.ServerOptionValues":"server","tmux.Server":"server","tmux.NewServer":"server","tmux.SessionFromEnv":"session","tmux.SessionID":"session","tmux.Session":"session","tmux.SessionOptionValues":"session","tmux.GlobalSessionScope":"session","tmux.ValidateSessionName":"session","tmux.WindowFromEnv":"window","tmux.WindowID":"window","tmux.Window":"window","tmux.WindowSize":"window","tmux.WindowOptionValues":"window","tmux.GlobalWindowScope":"window","tmux.NewWindowDirection":"window","tmux.RotateWindowDirection":"window","tmux.WindowResizeDirection":"window","workspace.Window":"window","tmux.WindowSizeLargest":"window","tmux.WindowSizeSmallest":"window","tmux.WindowSizeManual":"window","tmux.WindowSizeLatest":"window","tmux.NewWindowDirectionDefault":"window","tmux.NewWindowDirectionAfter":"window","tmux.NewWindowDirectionBefore":"window","tmux.RotateWindowDefault":"window","tmux.RotateWindowUp":"window","tmux.RotateWindowDown":"window","tmux.WindowResizeDirectionNone":"window","tmux.WindowResizeDirectionUp":"window","tmux.WindowResizeDirectionDown":"window","tmux.WindowResizeDirectionLeft":"window","tmux.WindowResizeDirectionRight":"window","tmux.PaneFromEnv":"pane","tmux.PaneDirection":"pane","tmux.PaneID":"pane","tmux.Pane":"pane","tmux.PaneBorderIndicators":"pane","tmux.PaneBorderLines":"pane","tmux.PaneBorderStatus":"pane","tmux.PaneScrollbars":"pane","tmux.PaneScrollbarsPosition":"pane","tmux.PaneOptionValues":"pane","tmux.PaneResizeDirection":"pane","tmux.PaneSize":"pane","tmux.PaneCells":"pane","tmux.PanePercent":"pane","tmux.PaneText":"pane","tmux.SwapPaneDirection":"pane","tmux.PaneSelectDirection":"pane","workspace.Pane":"pane","tmux.PaneDirectionBelow":"pane","tmux.PaneDirectionAbove":"pane","tmux.PaneDirectionRight":"pane","tmux.PaneDirectionLeft":"pane","tmux.PaneBorderIndicatorsOff":"pane","tmux.PaneBorderIndicatorsColour":"pane","tmux.PaneBorderIndicatorsArrows":"pane","tmux.PaneBorderIndicatorsBoth":"pane","tmux.PaneBorderLinesSingle":"pane","tmux.PaneBorderLinesDouble":"pane","tmux.PaneBorderLinesHeavy":"pane","tmux.PaneBorderLinesSimple":"pane","tmux.PaneBorderLinesNumber":"pane","tmux.PaneBorderLinesSpaces":"pane","tmux.PaneBorderStatusOff":"pane","tmux.PaneBorderStatusTop":"pane","tmux.PaneBorderStatusBottom":"pane","tmux.PaneScrollbarsOff":"pane","tmux.PaneScrollbarsModal":"pane","tmux.PaneScrollbarsOn":"pane","tmux.PaneScrollbarsPositionRight":"pane","tmux.PaneScrollbarsPositionLeft":"pane","tmux.PaneResizeDirectionNone":"pane","tmux.PaneResizeDirectionUp":"pane","tmux.PaneResizeDirectionDown":"pane","tmux.PaneResizeDirectionLeft":"pane","tmux.PaneResizeDirectionRight":"pane","tmux.SwapPaneDirectionNone":"pane","tmux.SwapPaneDirectionUp":"pane","tmux.SwapPaneDirectionDown":"pane","tmux.PaneSelectDirectionNone":"pane","tmux.PaneSelectDirectionUp":"pane","tmux.PaneSelectDirectionDown":"pane","tmux.PaneSelectDirectionLeft":"pane","tmux.PaneSelectDirectionRight":"pane","tmux.PaneSelectDirectionLast":"pane","tmux.ClientAttachment":"client","tmux.ClientName":"client","tmux.Client":"client","tmux.ServerHookValues":"hooks","tmux.SessionHookValues":"hooks","tmux.WindowHookValues":"hooks","tmux.PaneHookValues":"hooks","tmux.AllowPassthrough":"options","tmux.CopyModeLineNumbers":"options","tmux.DestroyUnattached":"options","tmux.DetachOnDestroy":"options","tmux.ExtendedKeys":"options","tmux.GetClipboard":"options","tmux.MenuBorderLines":"options","tmux.MessageLine":"options","tmux.ModeKeys":"options","tmux.PopupBorderLines":"options","tmux.RemainOnExit":"options","tmux.SetClipboard":"options","tmux.Status":"options","tmux.StatusJustify":"options","tmux.StatusKeys":"options","tmux.StatusPosition":"options","tmux.VisualActivity":"options","tmux.VisualBell":"options","tmux.VisualSilence":"options","tmux.OptionOrigin":"options","tmux.OptionValue":"options","tmux.AllowPassthroughOff":"options","tmux.AllowPassthroughOn":"options","tmux.AllowPassthroughAll":"options","tmux.CopyModeLineNumbersOff":"options","tmux.CopyModeLineNumbersDefault":"options","tmux.CopyModeLineNumbersAbsolute":"options","tmux.CopyModeLineNumbersRelative":"options","tmux.CopyModeLineNumbersHybrid":"options","tmux.DestroyUnattachedOff":"options","tmux.DestroyUnattachedOn":"options","tmux.DestroyUnattachedKeepLast":"options","tmux.DestroyUnattachedKeepGroup":"options","tmux.DetachOnDestroyOff":"options","tmux.DetachOnDestroyOn":"options","tmux.DetachOnDestroyNoDetached":"options","tmux.DetachOnDestroyPrevious":"options","tmux.DetachOnDestroyNext":"options","tmux.ExtendedKeysOff":"options","tmux.ExtendedKeysOn":"options","tmux.ExtendedKeysAlways":"options","tmux.GetClipboardOff":"options","tmux.GetClipboardBuffer":"options","tmux.GetClipboardRequest":"options","tmux.GetClipboardBoth":"options","tmux.MenuBorderLinesSingle":"options","tmux.MenuBorderLinesDouble":"options","tmux.MenuBorderLinesHeavy":"options","tmux.MenuBorderLinesSimple":"options","tmux.MenuBorderLinesRounded":"options","tmux.MenuBorderLinesPadded":"options","tmux.MenuBorderLinesNone":"options","tmux.MessageLine0":"options","tmux.MessageLine1":"options","tmux.MessageLine2":"options","tmux.MessageLine3":"options","tmux.MessageLine4":"options","tmux.ModeKeysEmacs":"options","tmux.ModeKeysVi":"options","tmux.PopupBorderLinesSingle":"options","tmux.PopupBorderLinesDouble":"options","tmux.PopupBorderLinesHeavy":"options","tmux.PopupBorderLinesSimple":"options","tmux.PopupBorderLinesRounded":"options","tmux.PopupBorderLinesPadded":"options","tmux.PopupBorderLinesNone":"options","tmux.RemainOnExitOff":"options","tmux.RemainOnExitOn":"options","tmux.RemainOnExitFailed":"options","tmux.RemainOnExitKey":"options","tmux.SetClipboardOff":"options","tmux.SetClipboardExternal":"options","tmux.SetClipboardOn":"options","tmux.StatusOff":"options","tmux.StatusOn":"options","tmux.Status2":"options","tmux.Status3":"options","tmux.Status4":"options","tmux.Status5":"options","tmux.StatusJustifyLeft":"options","tmux.StatusJustifyCentre":"options","tmux.StatusJustifyRight":"options","tmux.StatusJustifyAbsoluteCentre":"options","tmux.StatusKeysEmacs":"options","tmux.StatusKeysVi":"options","tmux.StatusPositionTop":"options","tmux.StatusPositionBottom":"options","tmux.VisualActivityOff":"options","tmux.VisualActivityOn":"options","tmux.VisualActivityBoth":"options","tmux.VisualBellOff":"options","tmux.VisualBellOn":"options","tmux.VisualBellBoth":"options","tmux.VisualSilenceOff":"options","tmux.VisualSilenceOn":"options","tmux.VisualSilenceBoth":"options","tmux.OptionOriginLocal":"options","tmux.OptionOriginInherited":"options","tmux.PrefixKey":"keys","tmux.PrefixPrimary":"keys","tmux.PrefixSecondary":"keys","tmux.EnvironmentValue":"environment","tmux.TerminalFeature":"capabilities","tmux.TerminalFeatures":"capabilities","tmux.TerminalOverrideValue":"capabilities","tmux.TerminalCapability":"capabilities","tmux.TerminalOverride":"capabilities","tmux.TerminalOverrideEntry":"capabilities","tmux.TerminalOverrides":"capabilities","tmux.ModulePath":"version","tmux.PackageVersion":"version","tmux.MinimumSupportedVersion":"version","tmux.MinimumConnectionVersion":"version","tmux.Version":"version","tmux.ParseVersion":"version","tmux.CommandAlias":"commands","tmux.CommandAliases":"commands","tmux.Connection":"commands","tmux.CommandTransport":"commands","tmux.CommandTrace":"commands","tmux.CommandObserver":"commands","tmux.Running":"commands","workspace.Command":"commands","tmux.CommandTransportProcess":"commands","tmux.CommandTransportConnection":"commands","tmux.ControlClient":"control","tmux.ControlNotification":"control","tmux.SubscriptionChange":"control","tmux.ParseControlNotification":"control","tmux.PaneObservation":"control","tmux.NotificationStream":"control","tmux.FormatValues":"formats","tmux.ExtendedKeysFormat":"formats","tmux.ExtendedKeysFormatCSIU":"formats","tmux.ExtendedKeysFormatXTerm":"formats","tmux.Ptr":"queries","tmux.FilterSchemaVersion":"queries","tmux.SessionFilter":"queries","tmux.WindowFilter":"queries","tmux.PaneFilter":"queries","tmux.ClientFilter":"queries","tmux.SessionIDIs":"queries","tmux.SessionNameIs":"queries","tmux.SessionAttachedIs":"queries","tmux.WindowSessionIDIs":"queries","tmux.WindowIDIs":"queries","tmux.WindowIndexIs":"queries","tmux.WindowNameIs":"queries","tmux.WindowActiveIs":"queries","tmux.PaneSessionIDIs":"queries","tmux.PaneWindowIDIs":"queries","tmux.PaneIDIs":"queries","tmux.PaneWindowIndexIs":"queries","tmux.PaneIndexIs":"queries","tmux.PaneCommandIs":"queries","tmux.PaneActiveIs":"queries","tmux.PaneTitleIs":"queries","tmux.ClientNameIs":"queries","tmux.ClientReadOnlyIs":"queries","tmux.WindowRel":"queries","tmux.PaneRel":"queries","tmux.ParseSessionLookup":"queries","tmux.ParseWindowLookup":"queries","tmux.ParsePaneLookup":"queries","tmux.ParseClientLookup":"queries","tmux.TmuxFilter":"queries","tmuxq.Filter":"queries","tmuxq.Matching":"queries","tmuxq.MatchingSeq":"queries","tmuxq.Where":"queries","tmuxq.First":"queries","tmuxq.ExactlyOne":"queries","tmuxq.WhereSeq":"queries","tmuxq.FirstSeq":"queries","tmuxq.ExactlyOneSeq":"queries","tmux.CapturePosition":"snapshots","tmux.CaptureLine":"snapshots","tmux.Snapshot":"snapshots","tmux.CaptureBoundary":"snapshots","tmux.Ref":"workspace","tmux.Op":"workspace","tmux.Dispatch":"workspace","tmux.Sequential":"workspace","tmux.Folding":"workspace","tmux.OpStatus":"workspace","tmux.OpComplete":"workspace","tmux.OpFailed":"workspace","tmux.OpIndeterminate":"workspace","tmux.OpSkipped":"workspace","tmux.Plan":"workspace-plan","tmux.Planner":"workspace-plan","workspace.Workspace":"workspace-plan","tmux.NewPlan":"workspace-plan","tmux.SessionRef":"workspace-session","tmux.WindowRef":"workspace-window","tmux.PaneRef":"workspace-pane","workspace.Build":"workspace-functions","workspace.BuildInto":"workspace-functions","workspace.Parse":"workspace-functions","tmux.DisplayMessageRequest":"requests","tmux.ErrInvalidRequest":"requests","tmux.SubscriptionRequest":"requests","tmux.ErrInvalidCaptureRequest":"requests","tmux.SendKeysRequest":"requests","tmux.SendKeySequenceRequest":"requests","tmux.ClearHistoryRequest":"requests","tmux.CopyModeRequest":"requests","tmux.ChooseTreeRequest":"requests","tmux.DisplayPopupRequest":"requests","tmux.PasteBufferRequest":"requests","tmux.SetPlanOptionRequest":"requests","tmux.PromptHistoryRequest":"requests","tmux.SetBufferRequest":"requests","tmux.SaveBufferRequest":"requests","tmux.LoadBufferRequest":"requests","tmux.ListBuffersRequest":"requests","tmux.RunShellRequest":"requests","tmux.WaitForRequest":"requests","tmux.IfShellRequest":"requests","tmux.SourceFileRequest":"requests","tmux.ConfirmBeforeRequest":"requests","tmux.CommandPromptRequest":"requests","tmux.DisplayMenuRequest":"requests","tmux.BindKeyRequest":"requests","tmux.UnbindKeyRequest":"requests","tmux.ListKeysRequest":"requests","tmux.ListCommandsRequest":"requests","tmux.ShowMessagesRequest":"requests","tmux.SelectLayoutRequest":"requests","tmux.RespawnRequest":"requests","tmux.ServerAccessRequest":"requests-server","tmux.ErrInvalidServerCommandRequest":"requests-server","tmux.SessionKillRequest":"requests-session","tmux.AttachSessionRequest":"requests-session","tmux.HasSessionRequest":"requests-session","tmux.NewSessionRequest":"requests-session","tmux.KillWindowRequest":"requests-window","tmux.FindWindowRequest":"requests-window","tmux.SelectWindowRequest":"requests-window","tmux.NewWindowRequest":"requests-window","tmux.LinkWindowRequest":"requests-window","tmux.UnlinkWindowRequest":"requests-window","tmux.MoveWindowRequest":"requests-window","tmux.SwapWindowRequest":"requests-window","tmux.WindowSelectPaneRequest":"requests-window","tmux.RotateWindowRequest":"requests-window","tmux.ResizeWindowRequest":"requests-window","tmux.PaneDisplayMessageRequest":"requests-pane","tmux.CapturePaneRequest":"requests-pane","tmux.NewPaneRequest":"requests-pane","tmux.SplitPaneRequest":"requests-pane","tmux.ResizePaneRequest":"requests-pane","tmux.DisplayPanesRequest":"requests-pane","tmux.PipePaneRequest":"requests-pane","tmux.MovePaneRequest":"requests-pane","tmux.JoinPaneRequest":"requests-pane","tmux.BreakPaneRequest":"requests-pane","tmux.SwapPaneRequest":"requests-pane","tmux.PaneSelectRequest":"requests-pane","tmux.LastPaneRequest":"requests-pane","tmux.RefreshClientRequest":"requests-client","tmux.DetachClientRequest":"requests-client","tmux.DetachAllClientsRequest":"requests-client","tmux.ErrUnknownColor":"errors","tmux.ErrCommand":"errors","tmux.ErrNotFound":"errors","tmux.ColorError":"errors","tmux.CommandError":"errors","tmux.ErrMalformedComplexOption":"errors","tmux.ComplexOptionDecodeError":"errors","tmux.ErrConnectionRequiresProcess":"errors","tmux.ErrControlClosed":"errors","tmux.ErrControlStreamLost":"errors","tmux.ErrOutcomeUnknown":"errors","tmux.ErrControlReplyCount":"errors","tmux.ErrMalformedControlNotification":"errors","tmux.ErrUnknownControlNotification":"errors","tmux.ControlNotificationError":"errors","tmux.ErrControlNotificationOverflow":"errors","tmux.ControlNotificationOverflowError":"errors","tmux.ErrControlProtocol":"errors","tmux.ControlProtocolError":"errors","tmux.ErrInvalidEnvironmentName":"errors","tmux.ErrInvalidEnvironmentValue":"errors","tmux.ErrMalformedEnvironment":"errors","tmux.EnvironmentNameError":"errors","tmux.EnvironmentValueError":"errors","tmux.EnvironmentDecodeError":"errors","tmux.ErrInvalidFilter":"errors","tmux.ErrMalformedFormatOutput":"errors","tmux.FormatDecodeError":"errors","tmux.ErrNotInsideTmux":"errors","tmux.FromEnvError":"errors","tmux.ErrDaemonReplaced":"errors","tmux.ErrInvalidCommandOutput":"errors","tmux.ErrMalformedOptionOutput":"errors","tmux.OptionDecodeError":"errors","tmux.ErrOption":"errors","tmux.ErrUnknownOption":"errors","tmux.ErrInvalidOption":"errors","tmux.ErrInvalidOptionValue":"errors","tmux.ErrAmbiguousOption":"errors","tmux.ErrOptionTarget":"errors","tmux.OptionValueError":"errors","tmux.OptionError":"errors","tmux.CaptureRequestError":"errors","tmux.ErrPlan":"errors","tmux.PlanError":"errors","tmux.ErrPollCondition":"errors","tmux.ErrMissingSubcommand":"errors","tmux.ErrVersionQuery":"errors","tmux.ErrVersionTooLow":"errors","tmux.VersionQueryError":"errors","tmux.VersionTooLowError":"errors","tmux.ErrOutcomeUnrecorded":"errors","tmux.ErrMalformedSnapshot":"errors","tmux.ErrSnapshotAmbiguous":"errors","tmux.SnapshotDecodeError":"errors","tmux.SnapshotLookupError":"errors","tmux.ErrInvalidSparseIndex":"errors","tmux.ErrDuplicateSparseIndex":"errors","tmux.ErrMissingTarget":"errors","tmux.ErrInvalidTarget":"errors","tmux.TargetError":"errors","tmux.MissingTargetError":"errors","tmux.ErrInvalidVersion":"errors","tmux.VersionError":"errors","tmuxq.ErrNoMatch":"errors","tmuxq.ErrMultipleMatches":"errors","workspace.ErrInvalidWorkspace":"errors","tmux.ErrNoServer":"errors-server","tmux.ServerCommandRequestError":"errors-server","tmux.ErrInvalidServer":"errors-server","tmux.ErrInvalidServerOptions":"errors-server","tmux.ErrSessionExists":"errors-session","tmux.ErrPaneObservationLost":"errors-pane","tmux.ColorMode":"constants","tmux.CommandResult":"constants","tmux.TerminalOverrideValueKind":"constants","tmux.ConnectionOptions":"constants","tmux.ControlCommandResult":"constants","tmux.SetEnvironmentOptions":"constants","tmux.SetHooksOptions":"constants","tmux.SetHooksResult":"constants","tmux.NotificationOptions":"constants","tmux.ActivityAction":"constants","tmux.BellAction":"constants","tmux.ClockModeStyle":"constants","tmux.CursorStyle":"constants","tmux.PromptCommandCursorStyle":"constants","tmux.PromptCursorStyle":"constants","tmux.SilenceAction":"constants","tmux.ControlNotificationKind":"constants","tmux.SetOptionOptions":"constants","tmux.UnsetOptionOptions":"constants","tmux.SetArrayResult":"constants","tmux.PlanResult":"constants","tmux.OpResult":"constants","tmux.LoadBufferFromOptions":"constants","tmux.SaveBufferToOptions":"constants","tmux.WaitForMode":"constants","tmux.RunOptions":"constants","tmux.RunResult":"constants","tmux.WarningKind":"constants","tmux.ColorDefault":"constants","tmux.Color256":"constants","tmux.TerminalOverrideValueFlag":"constants","tmux.TerminalOverrideValueInteger":"constants","tmux.TerminalOverrideValueText":"constants","tmux.ActivityActionNone":"constants","tmux.ActivityActionAny":"constants","tmux.ActivityActionCurrent":"constants","tmux.ActivityActionOther":"constants","tmux.BellActionNone":"constants","tmux.BellActionAny":"constants","tmux.BellActionCurrent":"constants","tmux.BellActionOther":"constants","tmux.ClockModeStyle12":"constants","tmux.ClockModeStyle24":"constants","tmux.ClockModeStyle12WithSeconds":"constants","tmux.ClockModeStyle24WithSeconds":"constants","tmux.CursorStyleDefault":"constants","tmux.CursorStyleBlinkingBlock":"constants","tmux.CursorStyleBlock":"constants","tmux.CursorStyleBlinkingUnderline":"constants","tmux.CursorStyleUnderline":"constants","tmux.CursorStyleBlinkingBar":"constants","tmux.CursorStyleBar":"constants","tmux.PromptCommandCursorStyleDefault":"constants","tmux.PromptCommandCursorStyleBlinkingBlock":"constants","tmux.PromptCommandCursorStyleBlock":"constants","tmux.PromptCommandCursorStyleBlinkingUnderline":"constants","tmux.PromptCommandCursorStyleUnderline":"constants","tmux.PromptCommandCursorStyleBlinkingBar":"constants","tmux.PromptCommandCursorStyleBar":"constants","tmux.PromptCursorStyleDefault":"constants","tmux.PromptCursorStyleBlinkingBlock":"constants","tmux.PromptCursorStyleBlock":"constants","tmux.PromptCursorStyleBlinkingUnderline":"constants","tmux.PromptCursorStyleUnderline":"constants","tmux.PromptCursorStyleBlinkingBar":"constants","tmux.PromptCursorStyleBar":"constants","tmux.SilenceActionNone":"constants","tmux.SilenceActionAny":"constants","tmux.SilenceActionCurrent":"constants","tmux.SilenceActionOther":"constants","tmux.ControlNotificationClientDetached":"constants","tmux.ControlNotificationClientSessionChanged":"constants","tmux.ControlNotificationConfigError":"constants","tmux.ControlNotificationContinue":"constants","tmux.ControlNotificationExit":"constants","tmux.ControlNotificationExtendedOutput":"constants","tmux.ControlNotificationLayoutChange":"constants","tmux.ControlNotificationMessage":"constants","tmux.ControlNotificationOutput":"constants","tmux.ControlNotificationPaneModeChanged":"constants","tmux.ControlNotificationPasteBufferChanged":"constants","tmux.ControlNotificationPasteBufferDeleted":"constants","tmux.ControlNotificationPause":"constants","tmux.ControlNotificationSessionChanged":"constants","tmux.ControlNotificationSessionRenamed":"constants","tmux.ControlNotificationSessionWindowChanged":"constants","tmux.ControlNotificationSessionsChanged":"constants","tmux.ControlNotificationSubscriptionChanged":"constants","tmux.ControlNotificationUnlinkedWindowAdd":"constants","tmux.ControlNotificationUnlinkedWindowClose":"constants","tmux.ControlNotificationUnlinkedWindowRenamed":"constants","tmux.ControlNotificationWindowAdd":"constants","tmux.ControlNotificationWindowClose":"constants","tmux.ControlNotificationWindowPaneChanged":"constants","tmux.ControlNotificationWindowRenamed":"constants","tmux.WaitForModeWait":"constants","tmux.WaitForModeSignal":"constants","tmux.WaitForModeLock":"constants","tmux.WaitForModeUnlock":"constants","tmux.WarningUnsupportedFeature":"constants","tmux.WarningCommandStderr":"constants","tmux.ServerOptions":"constants-server","tmux.AttachSessionOptions":"constants-session","tmux.WindowSwapResult":"constants-window","tmux.PaneSwapResult":"constants-pane","tmux.PaneMarkMode":"constants-pane","tmux.PaneInputMode":"constants-pane","tmux.PaneMarkUnchanged":"constants-pane","tmux.PaneMarkSet":"constants-pane","tmux.PaneMarkClear":"constants-pane","tmux.PaneInputUnchanged":"constants-pane","tmux.PaneInputDisable":"constants-pane","tmux.PaneInputEnable":"constants-pane","mcp.Instance":"mcp","mcp.ServerSession":"mcp","mcp.HandshakeOrdered":"mcp-functions","mcp.MaterializeMinimalConfig":"mcp-functions","mcp.AssumeResponseCommit":"mcp-functions","mcp.NewServer":"mcp-functions","mcp.Run":"mcp-functions","mcp.RunDefaultMinimal":"mcp-functions","mcp.AdvertisedTools":"mcp-functions","mcp.AdvertisedToolsFor":"mcp-functions","mcp.ToolDetails":"mcp-functions","mcp.AuditEnvironmentVariable":"mcp-constants","mcp.ErrInstanceClosed":"mcp-constants","mcp.ErrRequestCapacity":"mcp-constants","mcp.CapabilitiesResourceURI":"mcp-constants","mcp.ErrResponseCommitUnknown":"mcp-constants","mcp.ErrRuntimeTargetBound":"mcp-constants","mcp.Version":"mcp-constants","mcp.CapabilityMetaKey":"mcp-constants","mcp.SocketEnvironmentVariable":"mcp-constants","mcp.SocketPathEnvironmentVariable":"mcp-constants","mcp.TmuxConfigEnvironmentVariable":"mcp-constants","mcp.BinaryEnvironmentVariable":"mcp-constants","mcp.ToolsetsEnvironmentVariable":"mcp-constants","mcp.ToolsEnvironmentVariable":"mcp-constants","mcp.ExcludeToolsEnvironmentVariable":"mcp-constants","mcp.SafetyEnvironmentVariable":"mcp-constants","mcp.RecipeToolEnvironmentVariable":"mcp-constants","mcp.WaitCeilingEnvironmentVariable":"mcp-constants","tmux.MaximumTestedVersion":"testing","tmuxtest.ControlMode":"testing","tmuxtest.ServerOptions":"testing","tmuxtest.ShellPrompt":"testing","tmuxtest.SuiteRootTagVariable":"testing","tmuxtest.Main":"testing","tmuxtest.NewServer":"testing","tmuxtest.NewServerWithOptions":"testing","tmuxtest.PTYProcess":"testing","tmuxtest.StartPTYProcess":"testing","tmuxtest.TemporaryNamePrefix":"testing","tmuxtest.NewSession":"testing","tmuxtest.NewWindow":"testing","tmuxtest.Screen":"testing","tmuxtest.WaitForText":"testing","tmuxtest.WaitForLine":"testing","tmuxtest.WaitForScreen":"testing","tmuxtest.WaitForShellReady":"testing","tmuxtest.Type":"testing","tmuxtest.TypeAndWait":"testing","tmuxtest.RunInPane":"testing","tmuxtest.ScriptedCommand":"testing","tmuxtest.ScriptedTmux":"testing","tmuxtest.WaitFor":"testing","tmuxtest.NewControlMode":"testing","tmux.TreeSortOrder":"__unplaced","tmux.Poll":"__unplaced","tmux.PromptType":"__unplaced","tmux.MenuItem":"__unplaced","tmux.SocketSelection":"__unplaced","tmux.SparseEntry":"__unplaced","tmux.SparseArray":"__unplaced","tmux.UnsupportedPolicy":"__unplaced","tmux.Warning":"__unplaced","tmux.WarningHandler":"__unplaced","workspace.Bool":"__unplaced","tmux.TreeSortDefault":"__unplaced","tmux.TreeSortIndex":"__unplaced","tmux.TreeSortName":"__unplaced","tmux.TreeSortTime":"__unplaced","tmux.TreeSortSize":"__unplaced","tmux.PromptTypeAll":"__unplaced","tmux.PromptTypeCommand":"__unplaced","tmux.PromptTypeSearch":"__unplaced","tmux.PromptTypeTarget":"__unplaced","tmux.PromptTypeWindowTarget":"__unplaced","tmux.NewSparseArray":"__unplaced","tmux.FailUnsupported":"__unplaced","tmux.DegradeUnsupported":"__unplaced"},"unplaced":[{"id":"tmux.TreeSortOrder","name":"TreeSortOrder","slug":"tmux-treesortorder","kind":"struct"},{"id":"tmux.PromptType","name":"PromptType","slug":"tmux-prompttype","kind":"struct"},{"id":"tmux.MenuItem","name":"MenuItem","slug":"tmux-menuitem","kind":"struct"},{"id":"tmux.SocketSelection","name":"SocketSelection","slug":"tmux-socketselection","kind":"struct"},{"id":"tmux.SparseEntry","name":"SparseEntry","slug":"tmux-sparseentry","kind":"struct"},{"id":"tmux.SparseArray","name":"SparseArray","slug":"tmux-sparsearray","kind":"struct"},{"id":"tmux.UnsupportedPolicy","name":"UnsupportedPolicy","slug":"tmux-unsupportedpolicy","kind":"struct"},{"id":"tmux.Warning","name":"Warning","slug":"tmux-warning","kind":"struct"},{"id":"tmux.WarningHandler","name":"WarningHandler","slug":"tmux-warninghandler","kind":"struct"},{"id":"workspace.Bool","name":"Bool","slug":"workspace-bool","kind":"struct"},{"id":"tmux.DegradeUnsupported","name":"DegradeUnsupported","slug":"tmux-degradeunsupported","kind":"constant"},{"id":"tmux.FailUnsupported","name":"FailUnsupported","slug":"tmux-failunsupported","kind":"constant"},{"id":"tmux.PromptTypeAll","name":"PromptTypeAll","slug":"tmux-prompttypeall","kind":"constant"},{"id":"tmux.PromptTypeCommand","name":"PromptTypeCommand","slug":"tmux-prompttypecommand","kind":"constant"},{"id":"tmux.PromptTypeSearch","name":"PromptTypeSearch","slug":"tmux-prompttypesearch","kind":"constant"},{"id":"tmux.PromptTypeTarget","name":"PromptTypeTarget","slug":"tmux-prompttypetarget","kind":"constant"},{"id":"tmux.PromptTypeWindowTarget","name":"PromptTypeWindowTarget","slug":"tmux-prompttypewindowtarget","kind":"constant"},{"id":"tmux.TreeSortDefault","name":"TreeSortDefault","slug":"tmux-treesortdefault","kind":"constant"},{"id":"tmux.TreeSortIndex","name":"TreeSortIndex","slug":"tmux-treesortindex","kind":"constant"},{"id":"tmux.TreeSortName","name":"TreeSortName","slug":"tmux-treesortname","kind":"constant"},{"id":"tmux.TreeSortSize","name":"TreeSortSize","slug":"tmux-treesortsize","kind":"constant"},{"id":"tmux.TreeSortTime","name":"TreeSortTime","slug":"tmux-treesorttime","kind":"constant"},{"id":"tmux.NewSparseArray","name":"NewSparseArray","slug":"tmux-newsparsearray","kind":"function"},{"id":"tmux.Poll","name":"Poll","slug":"tmux-poll","kind":"function"}],"diagnostics":{"unmatched":[],"deadBuckets":["options-functions","options-constants","buffers","layout","queries-fields","queries-operators","queries-expressions","workspace-steps","workspace-targets","workspace-constants","errors-window","constants-client","runtime","async","internal","internal-commands","internal-options"],"ambiguous":[],"staleUnsettled":[]}}
diff --git a/site/src/data/api/go.paths.json b/site/src/data/api/go.paths.json
index 50b16852..d8bc1936 100644
--- a/site/src/data/api/go.paths.json
+++ b/site/src/data/api/go.paths.json
@@ -1 +1 @@
-{"port":"go","repo":"libtmux/libtmux-go","revision":"52968a3181c1c9e6d1b26c565d4b170968ae61c0","paths":[".agents/skills/testing-the-mcp-server/SKILL.md",".agents/skills/testing-the-mcp-server/references/cli-matrix.md",".agents/skills/testing-the-mcp-server/references/compare.py",".agents/skills/testing-the-mcp-server/references/drive.py",".github/CONTRIBUTING.md",".github/WRITING.md",".github/dependabot.yml",".github/workflows/tests.yml",".gitignore",".golangci.yml","AGENTS.md","BENCHMARKS.md","CHANGELOG.md","CLAUDE.md","DESIGN.md","LICENSE","PARITY.md","README.md","SECURITY.md","benchmarks/.golangci.yml","benchmarks/LICENSE","benchmarks/README.md","benchmarks/go.mod","benchmarks/main.go","benchmarks/matrix.go","benchmarks/matrix_test.go","benchmarks/process_counter.go","benchmarks/waits.go","examples/.golangci.yml","examples/LICENSE","examples/README.md","examples/byte-streams/README.md","examples/byte-streams/example_test.go","examples/byte-streams/main.go","examples/control-mode-subscribe/README.md","examples/control-mode-subscribe/example_test.go","examples/control-mode-subscribe/main.go","examples/environment/README.md","examples/environment/example_test.go","examples/environment/main.go","examples/fast-path/README.md","examples/fast-path/example_test.go","examples/fast-path/main.go","examples/filter-query/README.md","examples/filter-query/example_test.go","examples/filter-query/main.go","examples/go.mod","examples/internal/exampletest/exampletest.go","examples/option-hook-editing/README.md","examples/option-hook-editing/example_test.go","examples/option-hook-editing/main.go","examples/pane-io/README.md","examples/pane-io/example_test.go","examples/pane-io/main.go","examples/planned-build/README.md","examples/planned-build/example_test.go","examples/planned-build/main.go","examples/quickstart/README.md","examples/quickstart/example_test.go","examples/quickstart/main.go","examples/run-to-completion/README.md","examples/run-to-completion/example_test.go","examples/run-to-completion/main.go","examples/snapshot-browser/README.md","examples/snapshot-browser/example_test.go","examples/snapshot-browser/main.go","go.mod","go.work","internal/tools/.golangci.yml","internal/tools/README.md","internal/tools/go.mod","internal/tools/go.sum","internal/tools/mcp-swap/README.md","internal/tools/mcp-swap/config_changes.go","internal/tools/mcp-swap/format_jsonc.go","internal/tools/mcp-swap/format_toml.go","internal/tools/mcp-swap/formats.go","internal/tools/mcp-swap/formats_test.go","internal/tools/mcp-swap/main.go","internal/tools/mcp-swap/main_test.go","internal/tools/mcp-swap/native_contract_test.go","internal/tools/mcp-swap/native_diagnostics.go","internal/tools/mcp-swap/native_ledger.go","internal/tools/mcp-swap/native_transaction.go","internal/tools/mcp-swap/orchestration_test.go","internal/tools/mcp-swap/physical_identity_other.go","internal/tools/mcp-swap/physical_identity_unix.go","internal/tools/mcp-swap/physical_identity_windows.go","internal/tools/mcp-swap/preflight.go","internal/tools/mcp-swap/preflight_process_unix.go","internal/tools/mcp-swap/preflight_process_unix_test.go","internal/tools/mcp-swap/preflight_process_windows.go","internal/tools/mcp-swap/preflight_test.go","internal/tools/mcp-swap/recovery.go","internal/tools/mcp-swap/recovery_hardening_test.go","internal/tools/mcp-swap/sync_directory_other.go","internal/tools/mcp-swap/sync_directory_unix.go","internal/tools/mcp-swap/sync_directory_windows.go","internal/tools/mcp-swap/transaction_lock.go","internal/tools/mcp-swap/transaction_lock_interop_unix_test.go","internal/tools/mcp-swap/transaction_lock_other.go","internal/tools/mcp-swap/transaction_lock_unix.go","internal/tools/mcp-swap/transaction_race_test.go","mcp/.golangci.yml","mcp/AGENTS.md","mcp/CLAUDE.md","mcp/LICENSE","mcp/PARITY.md","mcp/README.md","mcp/TOOLS.md","mcp/audit.go","mcp/audit_test.go","mcp/backstop.go","mcp/backstop_test.go","mcp/batch_tools.go","mcp/benchmark_test.go","mcp/bounds.go","mcp/bounds_test.go","mcp/caller_tools.go","mcp/caller_tools_internal_test.go","mcp/capability_handlers.go","mcp/capability_manifest_test.go","mcp/capture_since.go","mcp/capture_tools.go","mcp/channel_tools.go","mcp/channel_tools_internal_test.go","mcp/cmd/libtmux-mcp/README.md","mcp/cmd/libtmux-mcp/main.go","mcp/cmd/libtmux-mcp/main_test.go","mcp/command_records.go","mcp/command_wrapper.go","mcp/command_wrapper_real_test.go","mcp/command_wrapper_traps_linux_test.go","mcp/creation_tools.go","mcp/creation_tools_internal_test.go","mcp/dependencies.go","mcp/doc.go","mcp/elicit.go","mcp/example_test.go","mcp/examples/agent-workflow/README.md","mcp/examples/agent-workflow/main.go","mcp/executable_fixture_internal_test.go","mcp/executable_fixture_test.go","mcp/framing.go","mcp/framing_test.go","mcp/go.mod","mcp/go.sum","mcp/handshake_transport.go","mcp/handshake_transport_internal_test.go","mcp/harness_test.go","mcp/input_attended_linux_test.go","mcp/input_preflight_internal_test.go","mcp/input_preflight_real_test.go","mcp/input_tools.go","mcp/inspect_tools.go","mcp/instance.go","mcp/instance_connect.go","mcp/instance_internal_test.go","mcp/instance_lifecycle.go","mcp/internal/generate/toolsref/main.go","mcp/layout_tools.go","mcp/layout_tools_internal_test.go","mcp/layout_tools_real_test.go","mcp/lifecycle_internal_test.go","mcp/lifecycle_tools.go","mcp/logging.go","mcp/manifest_catalog.go","mcp/minimal.conf","mcp/minimal_config.go","mcp/orientation_tools.go","mcp/orientation_tools_internal_test.go","mcp/own_client_test.go","mcp/pane_observation.go","mcp/pane_run.go","mcp/pattern_limits.go","mcp/pattern_limits_test.go","mcp/pending_input.go","mcp/position_tools.go","mcp/progress.go","mcp/progress_internal_test.go","mcp/resources.go","mcp/response_ledger.go","mcp/response_ledger_internal_test.go","mcp/response_transport.go","mcp/response_transport_test.go","mcp/run_command_authority_test.go","mcp/run_command_route_linux_test.go","mcp/run_command_tools.go","mcp/runtime.go","mcp/runtime_internal_test.go","mcp/runtime_lifecycle.go","mcp/runtime_observation.go","mcp/runtime_recovery_test.go","mcp/runtime_request.go","mcp/server.go","mcp/server.json","mcp/server_tools.go","mcp/session_scope.go","mcp/session_transport.go","mcp/session_transport_internal_test.go","mcp/settings_tools.go","mcp/summaries.go","mcp/surface_empty_test.go","mcp/surface_schema_test.go","mcp/targets.go","mcp/tool_catalog.go","mcp/tool_catalog_target_test.go","mcp/tool_catalog_test.go","mcp/tool_manifest.go","mcp/tool_surface.go","mcp/version_test.go","mcp/wait_entry_test.go","mcp/wait_for_text_internal_test.go","mcp/wait_for_text_tools.go","mcp/wait_tools.go","mcp/wait_tools_internal_test.go","scripts/matrix.sh","tmux/README.md","tmux/build_info.go","tmux/build_info_external_test.go","tmux/build_info_test.go","tmux/client_attachment.go","tmux/client_attachment_test.go","tmux/command.go","tmux/command_test.go","tmux/complex_options.go","tmux/complex_options_test.go","tmux/concurrency_test.go","tmux/connection.go","tmux/connection_call_test.go","tmux/connection_external_test.go","tmux/connection_test.go","tmux/context_contract_test.go","tmux/control_client.go","tmux/control_client_external_test.go","tmux/control_client_test.go","tmux/control_engine.go","tmux/control_lifecycle.go","tmux/control_notification.go","tmux/control_notification_external_test.go","tmux/control_notification_queue.go","tmux/control_notification_queue_test.go","tmux/control_notification_test.go","tmux/control_observation.go","tmux/control_observation_test.go","tmux/control_pool.go","tmux/control_pool_test.go","tmux/control_protocol.go","tmux/control_protocol_test.go","tmux/control_reconnect_test.go","tmux/control_request.go","tmux/control_startup.go","tmux/control_stream.go","tmux/display_message.go","tmux/display_message_test.go","tmux/doc.go","tmux/documentation_test.go","tmux/environment.go","tmux/environment_test.go","tmux/exact_target.go","tmux/exact_target_test.go","tmux/example_test.go","tmux/filter.go","tmux/filter_external_test.go","tmux/filter_generated.go","tmux/filter_test.go","tmux/format.go","tmux/format_external_test.go","tmux/format_fuzz_test.go","tmux/format_generated.go","tmux/format_test.go","tmux/from_env.go","tmux/from_env_test.go","tmux/global_scope_external_test.go","tmux/hierarchy.go","tmux/hierarchy_test.go","tmux/hook_runtime.go","tmux/hook_runtime_test.go","tmux/identity.go","tmux/identity_external_test.go","tmux/identity_real_test.go","tmux/identity_test.go","tmux/internal/generate/docs/isolation_test.go","tmux/internal/generate/docs/main.go","tmux/internal/generate/docs/main_test.go","tmux/internal/generate/filters/main.go","tmux/internal/generate/filters/main_test.go","tmux/internal/generate/filters/spec.json","tmux/internal/generate/formats/catalog_real_test.go","tmux/internal/generate/formats/main.go","tmux/internal/generate/formats/main_test.go","tmux/internal/generate/formats/spec.json","tmux/internal/generate/options/main.go","tmux/internal/generate/options/main_test.go","tmux/internal/generate/options/spec.json","tmux/internal/goname/goname.go","tmux/internal/goname/goname_test.go","tmux/internal/integration/classification_real_test.go","tmux/internal/integration/client_attachment_real_test.go","tmux/internal/integration/connection_real_test.go","tmux/internal/integration/control_client_real_test.go","tmux/internal/integration/control_intruder_real_test.go","tmux/internal/integration/control_locale_real_test.go","tmux/internal/integration/control_notification_real_test.go","tmux/internal/integration/control_observation_real_test.go","tmux/internal/integration/display_history_real_test.go","tmux/internal/integration/downstream_smoke_test.go","tmux/internal/integration/environment_real_test.go","tmux/internal/integration/example_real_test.go","tmux/internal/integration/floor_test.go","tmux/internal/integration/from_env_real_test.go","tmux/internal/integration/hierarchy_real_test.go","tmux/internal/integration/kill_options_real_test.go","tmux/internal/integration/lifecycle_creation_real_test.go","tmux/internal/integration/lifecycle_real_test.go","tmux/internal/integration/literal_argv_real_test.go","tmux/internal/integration/lookup_real_test.go","tmux/internal/integration/main_test.go","tmux/internal/integration/modules_test.go","tmux/internal/integration/observer_real_test.go","tmux/internal/integration/option_runtime_real_test.go","tmux/internal/integration/pane_capture_real_test.go","tmux/internal/integration/pane_geometry_real_test.go","tmux/internal/integration/pane_input_real_test.go","tmux/internal/integration/pane_modes_real_test.go","tmux/internal/integration/pane_popup_real_test.go","tmux/internal/integration/pane_process_real_test.go","tmux/internal/integration/plan_real_test.go","tmux/internal/integration/readme_test.go","tmux/internal/integration/search_real_test.go","tmux/internal/integration/server_attach_real_test.go","tmux/internal/integration/server_buffers_real_test.go","tmux/internal/integration/server_clients_real_test.go","tmux/internal/integration/server_exec_real_test.go","tmux/internal/integration/server_interactive_real_test.go","tmux/internal/integration/server_keys_real_test.go","tmux/internal/integration/session_name_target_real_test.go","tmux/internal/integration/session_window_ops_real_test.go","tmux/internal/integration/snapshot_real_test.go","tmux/internal/integration/socket_path_real_test.go","tmux/internal/integration/start_server_real_test.go","tmux/internal/integration/supported_test.go","tmux/internal/integration/version_gates_real_test.go","tmux/internal/integration/wait_for_lock_real_test.go","tmux/internal/integration/window_layout_real_test.go","tmux/internal/integration/window_pane_topology_real_test.go","tmux/internal/integration/window_respawn_real_test.go","tmux/internal/parity/manifest.json","tmux/internal/termtext/termtext.go","tmux/internal/termtext/termtext_test.go","tmux/internal/tmuxcmd/lookpath.go","tmux/internal/tmuxcmd/lookpath_path.go","tmux/internal/tmuxcmd/lookpath_plan9.go","tmux/internal/tmuxcmd/lookpath_unix.go","tmux/internal/tmuxcmd/lookpath_unix_test.go","tmux/internal/tmuxcmd/lookpath_wasm.go","tmux/internal/tmuxcmd/lookpath_windows.go","tmux/internal/tmuxcmd/lookpath_windows_test.go","tmux/internal/tmuxcmd/process_outcome.go","tmux/internal/tmuxcmd/process_outcome_other.go","tmux/internal/tmuxcmd/process_outcome_unix.go","tmux/internal/tmuxcmd/process_outcome_unix_test.go","tmux/internal/tmuxcmd/process_outcome_windows.go","tmux/internal/tmuxcmd/runner.go","tmux/internal/tmuxcmd/runner_stream_test.go","tmux/internal/tmuxcmd/runner_test.go","tmux/kill_options_test.go","tmux/kill_target_test.go","tmux/lifecycle.go","tmux/lifecycle_creation_test.go","tmux/lifecycle_kill.go","tmux/lifecycle_test.go","tmux/liveness_internal_test.go","tmux/liveness_test.go","tmux/lookup.go","tmux/lookup_test.go","tmux/marshal.go","tmux/marshal_test.go","tmux/model.go","tmux/notification_stream.go","tmux/notification_stream_external_test.go","tmux/notification_stream_test.go","tmux/observer.go","tmux/observer_test.go","tmux/option_decode.go","tmux/option_decode_fuzz_test.go","tmux/option_decode_test.go","tmux/option_error.go","tmux/option_generated.go","tmux/option_generated_external_test.go","tmux/option_generated_test.go","tmux/option_mutation.go","tmux/option_read.go","tmux/option_runtime.go","tmux/option_runtime_test.go","tmux/option_scope.go","tmux/option_value.go","tmux/option_value_test.go","tmux/package_external_test.go","tmux/pane_capture.go","tmux/pane_capture_test.go","tmux/pane_create.go","tmux/pane_geometry.go","tmux/pane_geometry_test.go","tmux/pane_input.go","tmux/pane_input_test.go","tmux/pane_modes.go","tmux/pane_modes_test.go","tmux/pane_popup.go","tmux/pane_popup_test.go","tmux/pane_position_test.go","tmux/pane_process.go","tmux/pane_process_test.go","tmux/pane_relocate.go","tmux/pane_wait.go","tmux/pane_wait_test.go","tmux/parity_manifest_test.go","tmux/parity_omission_test.go","tmux/pipe_stream.go","tmux/pipe_stream_external_test.go","tmux/plan.go","tmux/plan_pane.go","tmux/plan_policy_test.go","tmux/plan_server.go","tmux/plan_session.go","tmux/plan_window.go","tmux/poll.go","tmux/poll_test.go","tmux/process_environment.go","tmux/process_environment_other.go","tmux/process_environment_plan9.go","tmux/process_environment_windows.go","tmux/prompt_history.go","tmux/prompt_history_test.go","tmux/relations.go","tmux/relations_test.go","tmux/request_types_api_test.go","tmux/scoped_command.go","tmux/scoped_command_test.go","tmux/search.go","tmux/search_test.go","tmux/server.go","tmux/server_attach.go","tmux/server_attach_test.go","tmux/server_buffers.go","tmux/server_buffers_test.go","tmux/server_clients.go","tmux/server_clients_test.go","tmux/server_exec.go","tmux/server_exec_test.go","tmux/server_interactive.go","tmux/server_interactive_test.go","tmux/server_keys.go","tmux/server_keys_test.go","tmux/server_options.go","tmux/server_options_test.go","tmux/server_version.go","tmux/server_version_test.go","tmux/session_lifecycle.go","tmux/session_name_test.go","tmux/session_navigation.go","tmux/session_navigation_test.go","tmux/session_run.go","tmux/session_run_test.go","tmux/session_start_real_test.go","tmux/snapshot.go","tmux/snapshot_capture.go","tmux/snapshot_decode.go","tmux/snapshot_test.go","tmux/socket_selection.go","tmux/socket_selection_test.go","tmux/sparse_array.go","tmux/sparse_array_test.go","tmux/target.go","tmux/target_test.go","tmux/tmuxtest/README.md","tmux/tmuxtest/cleanup_test.go","tmux/tmuxtest/control.go","tmux/tmuxtest/control_internal_test.go","tmux/tmuxtest/control_spool.go","tmux/tmuxtest/control_test.go","tmux/tmuxtest/example_test.go","tmux/tmuxtest/harness.go","tmux/tmuxtest/harness_options_api_test.go","tmux/tmuxtest/harness_options_internal_test.go","tmux/tmuxtest/harness_options_test.go","tmux/tmuxtest/harness_test.go","tmux/tmuxtest/platform_unix.go","tmux/tmuxtest/platform_unsupported.go","tmux/tmuxtest/pty_process.go","tmux/tmuxtest/pty_process_api_test.go","tmux/tmuxtest/pty_process_linux.go","tmux/tmuxtest/pty_process_linux_test.go","tmux/tmuxtest/pty_process_unsupported.go","tmux/tmuxtest/resources.go","tmux/tmuxtest/resources_api_test.go","tmux/tmuxtest/resources_internal_test.go","tmux/tmuxtest/resources_test.go","tmux/tmuxtest/screen.go","tmux/tmuxtest/screen_test.go","tmux/tmuxtest/scripted.go","tmux/tmuxtest/scripted_api_test.go","tmux/tmuxtest/wait.go","tmux/tmuxtest/wait_test.go","tmux/tracked_binary_test.go","tmux/transport.go","tmux/transport_surface_external_test.go","tmux/truncation_internal_test.go","tmux/unsupported_test.go","tmux/version.go","tmux/version_test.go","tmux/warning.go","tmux/warning_test.go","tmux/window_layout.go","tmux/window_layout_test.go","tmux/window_lifecycle.go","tmux/window_link_move.go","tmux/window_link_move_test.go","tmux/window_pane_swap.go","tmux/window_pane_topology.go","tmux/window_pane_topology_test.go","tmux/window_resize.go","tmux/window_resize_test.go","tmux/window_respawn.go","tmux/window_respawn_test.go","tmuxq/README.md","tmuxq/doc.go","tmuxq/example_test.go","tmuxq/filter.go","tmuxq/filter_test.go","tmuxq/query.go","tmuxq/query_test.go","workspace/.golangci.yml","workspace/LICENSE","workspace/README.md","workspace/builder.go","workspace/command.go","workspace/example_test.go","workspace/examples/build-workspace/README.md","workspace/examples/build-workspace/main.go","workspace/go.mod","workspace/go.sum","workspace/workspace.go","workspace/workspace_test.go"]}
+{"port":"go","repo":"libtmux/libtmux-go","revision":"bb06e26e116e941813ca40bf45e7e3a47d38f52a","paths":[".agents/skills/testing-the-mcp-server/SKILL.md",".agents/skills/testing-the-mcp-server/references/cli-matrix.md",".agents/skills/testing-the-mcp-server/references/compare.py",".agents/skills/testing-the-mcp-server/references/drive.py",".github/CONTRIBUTING.md",".github/WRITING.md",".github/dependabot.yml",".github/workflows/tests.yml",".gitignore",".golangci.yml","AGENTS.md","BENCHMARKS.md","CHANGELOG.md","CLAUDE.md","DESIGN.md","LICENSE","PARITY.md","README.md","SECURITY.md","benchmarks/.golangci.yml","benchmarks/LICENSE","benchmarks/README.md","benchmarks/go.mod","benchmarks/main.go","benchmarks/matrix.go","benchmarks/matrix_test.go","benchmarks/process_counter.go","benchmarks/waits.go","examples/.golangci.yml","examples/LICENSE","examples/README.md","examples/byte-streams/README.md","examples/byte-streams/example_test.go","examples/byte-streams/main.go","examples/control-mode-subscribe/README.md","examples/control-mode-subscribe/example_test.go","examples/control-mode-subscribe/main.go","examples/environment/README.md","examples/environment/example_test.go","examples/environment/main.go","examples/fast-path/README.md","examples/fast-path/example_test.go","examples/fast-path/main.go","examples/filter-query/README.md","examples/filter-query/example_test.go","examples/filter-query/main.go","examples/go.mod","examples/internal/exampletest/exampletest.go","examples/option-hook-editing/README.md","examples/option-hook-editing/example_test.go","examples/option-hook-editing/main.go","examples/pane-io/README.md","examples/pane-io/example_test.go","examples/pane-io/main.go","examples/planned-build/README.md","examples/planned-build/example_test.go","examples/planned-build/main.go","examples/quickstart/README.md","examples/quickstart/example_test.go","examples/quickstart/main.go","examples/run-to-completion/README.md","examples/run-to-completion/example_test.go","examples/run-to-completion/main.go","examples/snapshot-browser/README.md","examples/snapshot-browser/example_test.go","examples/snapshot-browser/main.go","go.mod","go.work","internal/tools/.golangci.yml","internal/tools/README.md","internal/tools/go.mod","internal/tools/go.sum","internal/tools/mcp-swap/README.md","internal/tools/mcp-swap/config_changes.go","internal/tools/mcp-swap/format_jsonc.go","internal/tools/mcp-swap/format_toml.go","internal/tools/mcp-swap/formats.go","internal/tools/mcp-swap/formats_test.go","internal/tools/mcp-swap/main.go","internal/tools/mcp-swap/main_test.go","internal/tools/mcp-swap/native_contract_test.go","internal/tools/mcp-swap/native_diagnostics.go","internal/tools/mcp-swap/native_ledger.go","internal/tools/mcp-swap/native_transaction.go","internal/tools/mcp-swap/orchestration_test.go","internal/tools/mcp-swap/physical_identity_other.go","internal/tools/mcp-swap/physical_identity_unix.go","internal/tools/mcp-swap/physical_identity_windows.go","internal/tools/mcp-swap/preflight.go","internal/tools/mcp-swap/preflight_process_unix.go","internal/tools/mcp-swap/preflight_process_unix_test.go","internal/tools/mcp-swap/preflight_process_windows.go","internal/tools/mcp-swap/preflight_test.go","internal/tools/mcp-swap/recovery.go","internal/tools/mcp-swap/recovery_hardening_test.go","internal/tools/mcp-swap/sync_directory_other.go","internal/tools/mcp-swap/sync_directory_unix.go","internal/tools/mcp-swap/sync_directory_windows.go","internal/tools/mcp-swap/transaction_lock.go","internal/tools/mcp-swap/transaction_lock_interop_unix_test.go","internal/tools/mcp-swap/transaction_lock_other.go","internal/tools/mcp-swap/transaction_lock_unix.go","internal/tools/mcp-swap/transaction_race_test.go","mcp/.golangci.yml","mcp/AGENTS.md","mcp/CLAUDE.md","mcp/LICENSE","mcp/PARITY.md","mcp/README.md","mcp/TOOLS.md","mcp/audit.go","mcp/audit_test.go","mcp/backstop.go","mcp/backstop_test.go","mcp/batch_tools.go","mcp/benchmark_test.go","mcp/bounds.go","mcp/bounds_test.go","mcp/caller_tools.go","mcp/caller_tools_internal_test.go","mcp/capability_handlers.go","mcp/capability_manifest_test.go","mcp/capture_since.go","mcp/capture_tools.go","mcp/channel_tools.go","mcp/channel_tools_internal_test.go","mcp/cmd/libtmux-mcp/README.md","mcp/cmd/libtmux-mcp/main.go","mcp/cmd/libtmux-mcp/main_test.go","mcp/command_records.go","mcp/command_wrapper.go","mcp/command_wrapper_real_test.go","mcp/command_wrapper_traps_linux_test.go","mcp/creation_tools.go","mcp/creation_tools_internal_test.go","mcp/dependencies.go","mcp/doc.go","mcp/elicit.go","mcp/example_test.go","mcp/examples/agent-workflow/README.md","mcp/examples/agent-workflow/main.go","mcp/executable_fixture_internal_test.go","mcp/executable_fixture_test.go","mcp/framing.go","mcp/framing_test.go","mcp/go.mod","mcp/go.sum","mcp/handshake_transport.go","mcp/handshake_transport_internal_test.go","mcp/harness_test.go","mcp/input_attended_linux_test.go","mcp/input_preflight_internal_test.go","mcp/input_preflight_real_test.go","mcp/input_tools.go","mcp/inspect_tools.go","mcp/instance.go","mcp/instance_connect.go","mcp/instance_internal_test.go","mcp/instance_lifecycle.go","mcp/internal/generate/toolsref/main.go","mcp/layout_tools.go","mcp/layout_tools_real_test.go","mcp/lifecycle_internal_test.go","mcp/lifecycle_tools.go","mcp/lifecycle_tools_internal_test.go","mcp/logging.go","mcp/manifest_catalog.go","mcp/minimal.conf","mcp/minimal_config.go","mcp/orientation_tools.go","mcp/orientation_tools_internal_test.go","mcp/own_client_test.go","mcp/pane_observation.go","mcp/pane_run.go","mcp/pattern_limits.go","mcp/pattern_limits_test.go","mcp/pending_input.go","mcp/position_tools.go","mcp/progress.go","mcp/progress_internal_test.go","mcp/resources.go","mcp/response_ledger.go","mcp/response_ledger_internal_test.go","mcp/response_transport.go","mcp/response_transport_test.go","mcp/run_command_authority_test.go","mcp/run_command_route_linux_test.go","mcp/run_command_tools.go","mcp/runtime.go","mcp/runtime_internal_test.go","mcp/runtime_lifecycle.go","mcp/runtime_observation.go","mcp/runtime_recovery_test.go","mcp/runtime_request.go","mcp/server.go","mcp/server.json","mcp/server_tools.go","mcp/session_scope.go","mcp/session_transport.go","mcp/session_transport_internal_test.go","mcp/settings_tools.go","mcp/summaries.go","mcp/surface_empty_test.go","mcp/surface_schema_test.go","mcp/targets.go","mcp/tool_catalog.go","mcp/tool_catalog_target_test.go","mcp/tool_catalog_test.go","mcp/tool_manifest.go","mcp/tool_surface.go","mcp/version_test.go","mcp/wait_entry_test.go","mcp/wait_for_text_internal_test.go","mcp/wait_for_text_tools.go","mcp/wait_tools.go","mcp/wait_tools_internal_test.go","scripts/matrix.sh","tmux/README.md","tmux/build_info.go","tmux/build_info_external_test.go","tmux/build_info_test.go","tmux/client_attachment.go","tmux/client_attachment_test.go","tmux/command.go","tmux/command_test.go","tmux/complex_options.go","tmux/complex_options_test.go","tmux/concurrency_test.go","tmux/connection.go","tmux/connection_call_test.go","tmux/connection_external_test.go","tmux/connection_test.go","tmux/context_contract_test.go","tmux/control_client.go","tmux/control_client_external_test.go","tmux/control_client_test.go","tmux/control_engine.go","tmux/control_lifecycle.go","tmux/control_notification.go","tmux/control_notification_external_test.go","tmux/control_notification_queue.go","tmux/control_notification_queue_test.go","tmux/control_notification_test.go","tmux/control_observation.go","tmux/control_observation_test.go","tmux/control_pool.go","tmux/control_pool_test.go","tmux/control_protocol.go","tmux/control_protocol_test.go","tmux/control_reconnect_test.go","tmux/control_request.go","tmux/control_startup.go","tmux/control_stream.go","tmux/display_message.go","tmux/display_message_test.go","tmux/doc.go","tmux/documentation_test.go","tmux/environment.go","tmux/environment_test.go","tmux/exact_target.go","tmux/exact_target_test.go","tmux/example_test.go","tmux/filter.go","tmux/filter_external_test.go","tmux/filter_generated.go","tmux/filter_test.go","tmux/format.go","tmux/format_external_test.go","tmux/format_fuzz_test.go","tmux/format_generated.go","tmux/format_test.go","tmux/from_env.go","tmux/from_env_test.go","tmux/global_scope_external_test.go","tmux/hierarchy.go","tmux/hierarchy_test.go","tmux/hook_runtime.go","tmux/hook_runtime_test.go","tmux/identity.go","tmux/identity_external_test.go","tmux/identity_real_test.go","tmux/identity_test.go","tmux/internal/generate/docs/isolation_test.go","tmux/internal/generate/docs/main.go","tmux/internal/generate/docs/main_test.go","tmux/internal/generate/filters/main.go","tmux/internal/generate/filters/main_test.go","tmux/internal/generate/filters/spec.json","tmux/internal/generate/formats/catalog_real_test.go","tmux/internal/generate/formats/main.go","tmux/internal/generate/formats/main_test.go","tmux/internal/generate/formats/spec.json","tmux/internal/generate/options/main.go","tmux/internal/generate/options/main_test.go","tmux/internal/generate/options/spec.json","tmux/internal/goname/goname.go","tmux/internal/goname/goname_test.go","tmux/internal/integration/classification_real_test.go","tmux/internal/integration/client_attachment_real_test.go","tmux/internal/integration/connection_real_test.go","tmux/internal/integration/control_client_real_test.go","tmux/internal/integration/control_intruder_real_test.go","tmux/internal/integration/control_locale_real_test.go","tmux/internal/integration/control_notification_real_test.go","tmux/internal/integration/control_observation_real_test.go","tmux/internal/integration/display_history_real_test.go","tmux/internal/integration/downstream_smoke_test.go","tmux/internal/integration/environment_real_test.go","tmux/internal/integration/example_real_test.go","tmux/internal/integration/floor_test.go","tmux/internal/integration/from_env_real_test.go","tmux/internal/integration/hierarchy_real_test.go","tmux/internal/integration/kill_options_real_test.go","tmux/internal/integration/lifecycle_creation_real_test.go","tmux/internal/integration/lifecycle_real_test.go","tmux/internal/integration/literal_argv_real_test.go","tmux/internal/integration/lookup_real_test.go","tmux/internal/integration/main_test.go","tmux/internal/integration/modules_test.go","tmux/internal/integration/observer_real_test.go","tmux/internal/integration/option_runtime_real_test.go","tmux/internal/integration/pane_capture_real_test.go","tmux/internal/integration/pane_geometry_real_test.go","tmux/internal/integration/pane_input_real_test.go","tmux/internal/integration/pane_modes_real_test.go","tmux/internal/integration/pane_popup_real_test.go","tmux/internal/integration/pane_process_real_test.go","tmux/internal/integration/plan_real_test.go","tmux/internal/integration/readme_test.go","tmux/internal/integration/search_real_test.go","tmux/internal/integration/server_attach_real_test.go","tmux/internal/integration/server_buffers_real_test.go","tmux/internal/integration/server_clients_real_test.go","tmux/internal/integration/server_exec_real_test.go","tmux/internal/integration/server_interactive_real_test.go","tmux/internal/integration/server_keys_real_test.go","tmux/internal/integration/session_name_target_real_test.go","tmux/internal/integration/session_window_ops_real_test.go","tmux/internal/integration/snapshot_real_test.go","tmux/internal/integration/socket_path_real_test.go","tmux/internal/integration/start_server_real_test.go","tmux/internal/integration/supported_test.go","tmux/internal/integration/version_gates_real_test.go","tmux/internal/integration/wait_for_lock_real_test.go","tmux/internal/integration/window_layout_real_test.go","tmux/internal/integration/window_pane_topology_real_test.go","tmux/internal/integration/window_respawn_real_test.go","tmux/internal/layout/layout.go","tmux/internal/layout/layout_test.go","tmux/internal/layout/testdata/layout-preflight.json","tmux/internal/parity/manifest.json","tmux/internal/termtext/termtext.go","tmux/internal/termtext/termtext_test.go","tmux/internal/tmuxcmd/lookpath.go","tmux/internal/tmuxcmd/lookpath_path.go","tmux/internal/tmuxcmd/lookpath_plan9.go","tmux/internal/tmuxcmd/lookpath_unix.go","tmux/internal/tmuxcmd/lookpath_unix_test.go","tmux/internal/tmuxcmd/lookpath_wasm.go","tmux/internal/tmuxcmd/lookpath_windows.go","tmux/internal/tmuxcmd/lookpath_windows_test.go","tmux/internal/tmuxcmd/process_outcome.go","tmux/internal/tmuxcmd/process_outcome_other.go","tmux/internal/tmuxcmd/process_outcome_unix.go","tmux/internal/tmuxcmd/process_outcome_unix_test.go","tmux/internal/tmuxcmd/process_outcome_windows.go","tmux/internal/tmuxcmd/runner.go","tmux/internal/tmuxcmd/runner_stream_test.go","tmux/internal/tmuxcmd/runner_test.go","tmux/kill_options_test.go","tmux/kill_target_test.go","tmux/lifecycle.go","tmux/lifecycle_creation_test.go","tmux/lifecycle_kill.go","tmux/lifecycle_test.go","tmux/liveness_internal_test.go","tmux/liveness_test.go","tmux/lookup.go","tmux/lookup_test.go","tmux/marshal.go","tmux/marshal_test.go","tmux/model.go","tmux/notification_stream.go","tmux/notification_stream_external_test.go","tmux/notification_stream_test.go","tmux/observer.go","tmux/observer_test.go","tmux/option_decode.go","tmux/option_decode_fuzz_test.go","tmux/option_decode_test.go","tmux/option_error.go","tmux/option_generated.go","tmux/option_generated_external_test.go","tmux/option_generated_test.go","tmux/option_mutation.go","tmux/option_read.go","tmux/option_runtime.go","tmux/option_runtime_test.go","tmux/option_scope.go","tmux/option_value.go","tmux/option_value_test.go","tmux/package_external_test.go","tmux/pane_capture.go","tmux/pane_capture_test.go","tmux/pane_create.go","tmux/pane_geometry.go","tmux/pane_geometry_test.go","tmux/pane_input.go","tmux/pane_input_test.go","tmux/pane_modes.go","tmux/pane_modes_test.go","tmux/pane_popup.go","tmux/pane_popup_test.go","tmux/pane_position_test.go","tmux/pane_process.go","tmux/pane_process_test.go","tmux/pane_relocate.go","tmux/pane_wait.go","tmux/pane_wait_test.go","tmux/parity_manifest_test.go","tmux/parity_omission_test.go","tmux/pipe_stream.go","tmux/pipe_stream_external_test.go","tmux/plan.go","tmux/plan_pane.go","tmux/plan_policy_test.go","tmux/plan_server.go","tmux/plan_session.go","tmux/plan_window.go","tmux/poll.go","tmux/poll_test.go","tmux/process_environment.go","tmux/process_environment_other.go","tmux/process_environment_plan9.go","tmux/process_environment_windows.go","tmux/prompt_history.go","tmux/prompt_history_test.go","tmux/relations.go","tmux/relations_test.go","tmux/request_types_api_test.go","tmux/scoped_command.go","tmux/scoped_command_test.go","tmux/search.go","tmux/search_test.go","tmux/server.go","tmux/server_attach.go","tmux/server_attach_test.go","tmux/server_buffers.go","tmux/server_buffers_test.go","tmux/server_clients.go","tmux/server_clients_test.go","tmux/server_exec.go","tmux/server_exec_test.go","tmux/server_interactive.go","tmux/server_interactive_test.go","tmux/server_keys.go","tmux/server_keys_test.go","tmux/server_layout.go","tmux/server_layout_test.go","tmux/server_options.go","tmux/server_options_test.go","tmux/server_version.go","tmux/server_version_test.go","tmux/session_lifecycle.go","tmux/session_name_test.go","tmux/session_navigation.go","tmux/session_navigation_test.go","tmux/session_run.go","tmux/session_run_test.go","tmux/session_start_real_test.go","tmux/snapshot.go","tmux/snapshot_capture.go","tmux/snapshot_decode.go","tmux/snapshot_test.go","tmux/socket_selection.go","tmux/socket_selection_test.go","tmux/sparse_array.go","tmux/sparse_array_test.go","tmux/target.go","tmux/target_test.go","tmux/tmuxtest/README.md","tmux/tmuxtest/cleanup_test.go","tmux/tmuxtest/control.go","tmux/tmuxtest/control_internal_test.go","tmux/tmuxtest/control_spool.go","tmux/tmuxtest/control_test.go","tmux/tmuxtest/example_test.go","tmux/tmuxtest/harness.go","tmux/tmuxtest/harness_options_api_test.go","tmux/tmuxtest/harness_options_internal_test.go","tmux/tmuxtest/harness_options_test.go","tmux/tmuxtest/harness_test.go","tmux/tmuxtest/platform_unix.go","tmux/tmuxtest/platform_unsupported.go","tmux/tmuxtest/pty_process.go","tmux/tmuxtest/pty_process_api_test.go","tmux/tmuxtest/pty_process_linux.go","tmux/tmuxtest/pty_process_linux_test.go","tmux/tmuxtest/pty_process_unsupported.go","tmux/tmuxtest/resources.go","tmux/tmuxtest/resources_api_test.go","tmux/tmuxtest/resources_internal_test.go","tmux/tmuxtest/resources_test.go","tmux/tmuxtest/screen.go","tmux/tmuxtest/screen_test.go","tmux/tmuxtest/scripted.go","tmux/tmuxtest/scripted_api_test.go","tmux/tmuxtest/wait.go","tmux/tmuxtest/wait_test.go","tmux/tracked_binary_test.go","tmux/transport.go","tmux/transport_surface_external_test.go","tmux/truncation_internal_test.go","tmux/unsupported_test.go","tmux/version.go","tmux/version_test.go","tmux/warning.go","tmux/warning_test.go","tmux/window_layout.go","tmux/window_layout_test.go","tmux/window_lifecycle.go","tmux/window_link_move.go","tmux/window_link_move_test.go","tmux/window_pane_swap.go","tmux/window_pane_topology.go","tmux/window_pane_topology_test.go","tmux/window_resize.go","tmux/window_resize_test.go","tmux/window_respawn.go","tmux/window_respawn_test.go","tmuxq/README.md","tmuxq/doc.go","tmuxq/example_test.go","tmuxq/filter.go","tmuxq/filter_test.go","tmuxq/query.go","tmuxq/query_test.go","workspace/.golangci.yml","workspace/CLI.md","workspace/LICENSE","workspace/README.md","workspace/builder.go","workspace/cmd/tmux-workspace/main.go","workspace/command.go","workspace/example_test.go","workspace/examples/build-workspace/README.md","workspace/examples/build-workspace/main.go","workspace/go.mod","workspace/go.sum","workspace/internal/cli/cli.go","workspace/internal/cli/cli_test.go","workspace/internal/cli/document.go","workspace/internal/cli/document_test.go","workspace/internal/cli/files.go","workspace/internal/cli/files_other.go","workspace/internal/cli/files_unix.go","workspace/internal/cli/handoff.go","workspace/internal/cli/handoff_terminal_linux_test.go","workspace/internal/cli/handoff_terminal_other.go","workspace/internal/cli/handoff_terminal_unix.go","workspace/internal/cli/import.go","workspace/internal/cli/import_test.go","workspace/internal/cli/logging.go","workspace/internal/cli/logging_other.go","workspace/internal/cli/logging_unix.go","workspace/internal/cli/process.go","workspace/internal/cli/process_other.go","workspace/internal/cli/process_unix.go","workspace/internal/cli/progress.go","workspace/internal/cli/progress_terminal_linux_test.go","workspace/internal/cli/progress_test.go","workspace/internal/cli/prompt_other.go","workspace/internal/cli/prompt_test.go","workspace/internal/cli/prompt_unix.go","workspace/internal/cli/reference_test.go","workspace/internal/cli/search.go","workspace/internal/cli/services_test.go","workspace/internal/cli/tmux.go","workspace/internal/integration/cli_test.go","workspace/internal/integration/handoff_test.go","workspace/internal/integration/import_test.go","workspace/internal/integration/signals_linux_test.go","workspace/workspace.go","workspace/workspace_test.go"]}
diff --git a/site/src/data/example-sources.json b/site/src/data/example-sources.json
index 99721f2e..ef4582d9 100644
--- a/site/src/data/example-sources.json
+++ b/site/src/data/example-sources.json
@@ -1,26 +1,110 @@
 {
-  "dotnet:examples/LibTmux.Examples/Snippets/OneShot.cs": "using System.Runtime.Versioning;\n\nnamespace LibTmux.Examples.Snippets;\n\n/// <summary>The default mode: one command, one client, one materialized object.</summary>\n[UnsupportedOSPlatform(\"windows\")]\npublic static class OneShot\n{\n    /// <summary>Connects, builds a hierarchy, and types into the pane it made.</summary>\n    [Example(\"Connect, build a session and window, and type into a pane\")]\n    public static async Task ConnectAndBuild()\n    {\n        #region ConnectAndBuild\n        // Requires a tmux server already listening on this socket:\n        // ConnectAsync() discovers one, it never starts one. With nothing\n        // running yet, call Server.CreateOwnedAsync() instead.\n        Server server = await Server.ConnectAsync();\n        Session session = await server.CreateSessionAsync(new NewSessionRequest { Name = \"build\" });\n        Window window = await session.CreateWindowAsync(new NewWindowRequest { Name = \"tests\" });\n        Pane pane = (await window.GetPanesAsync())[0];\n\n        await pane.SendTextAsync(\"dotnet test\");\n        #endregion\n    }\n\n    /// <summary>Creates a window and prints what tmux answered about it.</summary>\n    [Example(\"One command, one materialized window\")]\n    public static async Task CreateWindow(Session session, CancellationToken ct)\n    {\n        #region CreateWindow\n        Window window = await session.CreateWindowAsync(new NewWindowRequest { Name = \"build\" }, ct);\n        Console.WriteLine($\"{window.Id} {window.Index}:{window.Name}\");\n        #endregion\n    }\n}\n",
-  "fsharp:examples/LibTmux.FSharp.Quickstart/Program.fs": "// fsharp-snippet: Quickstart\nopen System\nopen System.Threading\nopen LibTmux\nopen LibTmux.FSharp\n\nlet runAsync () =\n    task {\n        let binary =\n            match Environment.GetEnvironmentVariable(\"LIBTMUX_TMUX\") with\n            | null\n            | \"\" -> \"tmux\"\n            | value -> value\n\n        let options =\n            ServerConnectionOptions(\n                SocketName = \"fsharp-\" + Guid.NewGuid().ToString(\"N\"),\n                ConfigurationFile = \"/dev/null\",\n                TmuxBinaryPath = binary\n            )\n\n        use! ownedServer = LibTmux.Server.CreateOwnedAsync(options, CancellationToken.None)\n\n        use! _ownedSession =\n            ownedServer.Value.CreateOwnedSessionAsync(\n                NewSessionRequest(Name = \"demo\", WindowName = \"shell\", Command = \"/bin/sh\"),\n                CancellationToken.None\n            )\n\n        use! _ownedWorker =\n            ownedServer.Value.CreateOwnedSessionAsync(\n                NewSessionRequest(Name = \"worker\", WindowName = \"idle\", Command = \"/bin/sh\"),\n                CancellationToken.None\n            )\n\n        let! connected = LibTmux.Server.ConnectAsync(options, CancellationToken.None)\n\n        let! captured =\n            connected |> Server.capture CancellationToken.None SnapshotDepth.Panes\n\n        let session =\n            captured.Sessions |> Seq.find (fun candidate -> candidate.Name = \"demo\")\n\n        let window = session.Windows |> Seq.exactlyOne\n        let pane = window.Panes |> Seq.exactlyOne\n\n        let command =\n            pane\n            |> Pane.currentCommand\n            |> Option.defaultWith (fun () -> failwith \"The captured pane has no command.\")\n\n        let localMatches =\n            captured.Panes\n            |> Seq.filter (fun candidate -> candidate.Id = pane.Id)\n            |> Seq.length\n\n        let hasPane =\n            Filter.eq pane.Id PaneFields.id\n            |> Filter.any WindowFields.panes\n            |> Filter.any SessionFields.windows\n\n        let selected =\n            captured.Sessions\n            |> Query.matching hasPane\n            |> Selection.exactlyOne\n            |> Result.defaultWith (fun error -> failwithf \"Expected one matching session: %A\" error)\n\n        if\n            captured.Sessions.Count <> 2\n            || captured.Panes.Count <> 2\n            || window.Name <> \"shell\"\n            || localMatches <> 1\n            || selected.Id <> session.Id\n        then\n            failwith \"The captured graph and portable filter did not agree.\"\n\n        printfn \"%s / %s / %s\" session.Name window.Name command\n        printfn \"local pane matches: %d\" localMatches\n        printfn \"portable match: %s\" selected.Name\n    }\n\nrunAsync().GetAwaiter().GetResult()\n// endfsharp-snippet\n",
-  "go:examples/control-mode-subscribe/main.go": "// Command control-mode-subscribe watches a persistent tmux control client\n// receive changes without polling.\npackage main\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"log\"\n\t\"time\"\n\n\t\"github.com/libtmux/libtmux-go/tmux\"\n)\n\nfunc main() {\n\tif err := start(); err != nil {\n\t\tlog.Fatal(err)\n\t}\n}\n\n// start owns cleanup because log.Fatal skips deferred calls in main.\nfunc start() error {\n\tctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)\n\tdefer cancel()\n\n\tserver, err := tmux.NewServer(tmux.ServerOptions{})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"configure tmux server: %w\", err)\n\t}\n\treturn run(ctx, server)\n}\n\n// run accepts injected server state so tests can isolate the example.\nfunc run(ctx context.Context, server tmux.Server) (err error) {\n\tsession, err := server.NewSession(ctx, tmux.NewSessionRequest{Name: \"libtmux-control\"})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create session: %w\", err)\n\t}\n\tdefer func() {\n\t\tcleanupCtx, cleanupCancel := context.WithTimeout(context.WithoutCancel(ctx), time.Second)\n\t\tdefer cleanupCancel()\n\t\terr = errors.Join(err, session.Kill(cleanupCtx))\n\t}()\n\n\t// docs:watching given:ctx context.Context; session tmux.Session\n\tstream, err := session.OpenNotifications(ctx, tmux.NotificationOptions{})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"open notification stream: %w\", err)\n\t}\n\tdefer func() { err = errors.Join(err, stream.Close()) }()\n\n\t// Rename after subscribing; notifications do not include earlier changes.\n\tif _, err := session.Rename(ctx, \"control-example\"); err != nil {\n\t\treturn fmt.Errorf(\"rename session: %w\", err)\n\t}\n\n\tfor {\n\t\tnotification, err := stream.Next(ctx)\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"read notification: %w\", err)\n\t\t}\n\t\tfmt.Printf(\"notification: %s\\n\", notification.Kind())\n\t\tif notification.Kind() == tmux.ControlNotificationSessionRenamed {\n\t\t\tfmt.Println(\"heard the rename\")\n\t\t\tbreak\n\t\t}\n\t}\n\t// docs:end\n\n\t// docs:subscribing given:ctx context.Context; session tmux.Session; stream *tmux.NotificationStream\n\t// A subscription is a format tmux evaluates for you: it reports the value\n\t// when it first looks, about a second later, and then each time it changes.\n\tif err := stream.Subscribe(ctx, tmux.SubscriptionRequest{\n\t\tName: \"windows\", Format: \"#{session_windows}\",\n\t}); err != nil {\n\t\treturn fmt.Errorf(\"subscribe: %w\", err)\n\t}\n\tif _, err := session.NewWindow(ctx, tmux.NewWindowRequest{}); err != nil {\n\t\treturn fmt.Errorf(\"open window: %w\", err)\n\t}\n\tfor {\n\t\tnotification, err := stream.Next(ctx)\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"read notification: %w\", err)\n\t\t}\n\t\tif change, ok := notification.Subscription(); ok && change.Value == \"2\" {\n\t\t\tfmt.Println(\"session has\", change.Value, \"windows\")\n\t\t\treturn nil\n\t\t}\n\t}\n\t// docs:end\n}\n",
-  "go:examples/quickstart/main.go": "// Command quickstart demonstrates a complete session, window, and pane lifecycle.\npackage main\n\nimport (\n\t\"bufio\"\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"log\"\n\t\"time\"\n\n\t\"github.com/libtmux/libtmux-go/tmux\"\n)\n\nfunc main() {\n\tif err := start(); err != nil {\n\t\tlog.Fatal(err)\n\t}\n}\n\n// start owns cleanup because log.Fatal skips deferred calls in main.\nfunc start() error {\n\tctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)\n\tdefer cancel()\n\n\tserver, err := tmux.NewServer(tmux.ServerOptions{})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"configure tmux server: %w\", err)\n\t}\n\treturn run(ctx, server)\n}\n\n// run accepts injected server state so tests can isolate the example.\nfunc run(ctx context.Context, server tmux.Server) (err error) {\n\t// docs:quickstart given:ctx context.Context; server tmux.Server\n\tsession, err := server.NewSession(ctx, tmux.NewSessionRequest{\n\t\tName: \"libtmux-go-quickstart\", WindowName: \"start\",\n\t})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create session: %w\", err)\n\t}\n\tdefer func() {\n\t\tcleanupCtx, cleanupCancel := context.WithTimeout(context.WithoutCancel(ctx), time.Second)\n\t\tdefer cleanupCancel()\n\t\terr = errors.Join(err, session.Kill(cleanupCtx))\n\t}()\n\n\twindow, err := session.NewWindow(ctx, tmux.NewWindowRequest{Name: new(\"work\")})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create window: %w\", err)\n\t}\n\tpane, err := window.SplitPane(ctx, tmux.SplitPaneRequest{\n\t\tDirection: tmux.PaneDirectionRight, Command: \"sh\",\n\t})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"split window: %w\", err)\n\t}\n\toutput, err := pane.OpenObservation(ctx)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"watch pane: %w\", err)\n\t}\n\tdefer func() { err = errors.Join(err, output.Close()) }()\n\tif _, err := fmt.Fprintln(pane.Writer(ctx), \"printf 'libtmux ready\\\\n'\"); err != nil {\n\t\treturn fmt.Errorf(\"send command: %w\", err)\n\t}\n\t// docs:end\n\n\tscanner := bufio.NewScanner(output.Reader(ctx))\n\tfor scanner.Scan() {\n\t\tif scanner.Text() == \"libtmux ready\" {\n\t\t\tfmt.Println(\"libtmux ready\")\n\t\t\treturn nil\n\t\t}\n\t}\n\treturn fmt.Errorf(\"read pane: %w\", scanner.Err())\n}\n",
-  "go:workspace/example_test.go": "package workspace_test\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"time\"\n\n\t\"github.com/libtmux/libtmux-go/tmux\"\n\t\"github.com/libtmux/libtmux-go/workspace\"\n)\n\n// Load a tmuxp-style document and build the session it describes.\nfunc Example() {\n\tctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)\n\tdefer cancel()\n\tserver, err := tmux.NewServer(tmux.ServerOptions{\n\t\tSocketName: \"libtmux-go-example-workspace\",\n\t})\n\tif err != nil {\n\t\tfmt.Println(\"server:\", err)\n\t\treturn\n\t}\n\tdefer killExampleServer(server)\n\n\tdocument := []byte(`\nsession_name: review\nwindows:\n  - window_name: editor\n    panes:\n      - shell_command: printf 'ready\\n'\n  - window_name: tests\n    panes:\n      - shell_command: printf 'ready\\n'\n      - shell_command: printf 'ready\\n'\n`)\n\tparsed, err := workspace.Parse(document)\n\tif err != nil {\n\t\tfmt.Println(\"parse:\", err)\n\t\treturn\n\t}\n\n\tsession, err := workspace.Build(ctx, server, parsed)\n\tif err != nil {\n\t\tfmt.Println(\"build:\", err)\n\t\treturn\n\t}\n\n\tname, _ := session.Name()\n\twindows, err := session.SearchWindows(ctx, nil)\n\tif err != nil {\n\t\tfmt.Println(\"search windows:\", err)\n\t\treturn\n\t}\n\tfmt.Println(name, len(windows))\n\t// Output: review 2\n}\n\n// Create the initial session, prefer a retained connection where tmux supports\n// one, then populate the rest of the workspace through that session.\nfunc ExampleBuildInto() {\n\tctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)\n\tdefer cancel()\n\tserver, err := tmux.NewServer(tmux.ServerOptions{\n\t\tSocketName: \"libtmux-go-example-workspace-continue\",\n\t})\n\tif err != nil {\n\t\tfmt.Println(\"server:\", err)\n\t\treturn\n\t}\n\tdefer killExampleServer(server)\n\n\tdescribed := workspace.Workspace{\n\t\tSessionName: \"review\",\n\t\tWindows: []workspace.Window{\n\t\t\t{Name: \"editor\", Panes: []workspace.Pane{{Shell: \"sleep 60\"}}},\n\t\t\t{Name: \"tests\", Panes: []workspace.Pane{{Shell: \"sleep 60\"}}},\n\t\t},\n\t}\n\trequest, err := described.InitialSessionRequest()\n\tif err != nil {\n\t\tfmt.Println(\"request:\", err)\n\t\treturn\n\t}\n\t_, connection, err := server.NewSessionConnection(\n\t\tctx,\n\t\trequest,\n\t\ttmux.ConnectionOptions{},\n\t)\n\tif err != nil {\n\t\tfmt.Println(\"create:\", err)\n\t\treturn\n\t}\n\tdefer func() { _ = connection.Close() }()\n\tsession := connection.Session()\n\tif err := workspace.BuildInto(ctx, session, described); err != nil {\n\t\tfmt.Println(\"build:\", err)\n\t\treturn\n\t}\n\twindows, err := session.SearchWindows(ctx, nil)\n\tif err != nil {\n\t\tfmt.Println(\"search windows:\", err)\n\t\treturn\n\t}\n\tfmt.Println(len(windows))\n\t// Output: 2\n}\n\n// A misspelled key fails the parse rather than being dropped, so a workspace\n// that does not do what its author meant says so before anything is built.\nfunc ExampleParse_unknownField() {\n\t_, err := workspace.Parse([]byte(\"session_name: review\\nwindow:\\n  - {}\\n\"))\n\tfmt.Println(err != nil)\n\t// Output: true\n}\n\n// killExampleServer stops an example's server on a context of its own, since an\n// example's own context may already be spent by the time it returns.\nfunc killExampleServer(server tmux.Server) {\n\tctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\n\tdefer cancel()\n\t_ = server.Kill(ctx)\n}\n",
-  "java:examples/src/main/java/io/github/libtmux/examples/BuildAWorkspace.java": "package io.github.libtmux.examples;\n\nimport io.github.libtmux.Layout;\nimport io.github.libtmux.Pane;\nimport io.github.libtmux.Server;\nimport io.github.libtmux.ServerConfig;\nimport io.github.libtmux.ServerEndpoint;\nimport io.github.libtmux.ServerNotRunningException;\nimport io.github.libtmux.Session;\nimport io.github.libtmux.Window;\nimport java.nio.file.Path;\nimport java.util.Optional;\n\n/**\n * Lays out a session the way you would set one up by hand before starting work.\n *\n * <pre>{@code\n * java BuildAWorkspace.java /tmp/libtmux-java-dev/demo/s\n * }</pre>\n */\npublic final class BuildAWorkspace {\n\n    private BuildAWorkspace() {}\n\n    public static void main(String[] args) {\n        run(Path.of(args.length > 0 ? args[0] : \"/tmp/libtmux-java-dev/demo/s\"));\n    }\n\n    /** Separated from {@code main} so the suite can run exactly what a reader runs. */\n    public static String run(Path socket) {\n        ServerConfig config = ServerConfig.builder()\n                .endpoint(ServerEndpoint.socketPath(socket))\n                .configFile(Path.of(\"/dev/null\"))\n                .build();\n\n        // Closing a server closes this client. The tmux server, and the session, outlive the program\n        // — which is the whole point of tmux and the reason nothing here kills it.\n        try (Server server = Server.open(config)) {\n            // One read decides and answers. An absent daemon means the name cannot be taken, so\n            // that specific failure is the other way this resolves to \"not found\".\n            Optional<Session> existing;\n            try {\n                existing = server.session(\"work\");\n            } catch (ServerNotRunningException absent) {\n                existing = Optional.empty();\n            }\n            Session session = existing.orElseGet(() -> server.newSession(\"work\"));\n\n            Window editor = session.newWindow(window -> window.named(\"editor\").detached());\n            Pane shell = editor.split(split -> split.toRight());\n            shell.sendLine(\"git status --short\");\n\n            editor.selectLayout(Layout.MAIN_VERTICAL);\n\n            return \"session \" + session.name() + \" has \"\n                    + session.refresh().windows().size() + \" windows\";\n        }\n    }\n}\n",
-  "java:examples/src/main/java/io/github/libtmux/examples/WatchPaneOutput.java": "package io.github.libtmux.examples;\n\nimport io.github.libtmux.Server;\nimport io.github.libtmux.ServerConfig;\nimport io.github.libtmux.ServerEndpoint;\nimport io.github.libtmux.Session;\nimport io.github.libtmux.control.ControlClient;\nimport io.github.libtmux.control.EventSubscription;\nimport io.github.libtmux.control.PaneOutput;\nimport java.nio.file.Path;\nimport java.time.Duration;\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.function.Consumer;\n\n/**\n * Watches what a pane prints, as tmux pushes it, rather than polling for it.\n *\n * <pre>{@code\n * java WatchPaneOutput.java /tmp/libtmux-java-dev/demo/s\n * }</pre>\n */\npublic final class WatchPaneOutput {\n\n    private WatchPaneOutput() {}\n\n    public static void main(String[] args) {\n        Path socket = Path.of(args.length > 0 ? args[0] : \"/tmp/libtmux-java-dev/demo/s\");\n        run(socket, Duration.ofSeconds(10), output -> System.out.print(output.data()));\n    }\n\n    /**\n     * Separated from {@code main} so the suite can run exactly what a reader runs.\n     *\n     * @return everything seen before the deadline\n     */\n    public static List<PaneOutput> run(Path socket, Duration watchFor, Consumer<PaneOutput> onOutput) {\n        ServerConfig config = ServerConfig.builder()\n                .endpoint(ServerEndpoint.socketPath(socket))\n                .build();\n\n        List<PaneOutput> seen = new ArrayList<>();\n        try (Server server = Server.open(config)) {\n            Session session = server.sessions().get(0);\n\n            // Attaching is what makes tmux push %output at all. A client that never attaches hears\n            // about command replies and nothing else.\n            try (ControlClient client = ControlClient.attach(server.config(), session.id());\n                    EventSubscription<PaneOutput> output = client.subscribeOutput(32)) {\n                client.send(\"send-keys\", \"-t\", session.name(), \"echo watched\", \"Enter\");\n\n                long deadline = System.nanoTime() + watchFor.toNanos();\n                while (System.nanoTime() < deadline && seen.isEmpty()) {\n                    try {\n                        var next = output.next(Duration.ofNanos(Math.max(0L, deadline - System.nanoTime())));\n                        if (next.isEmpty()) {\n                            break;\n                        }\n                        PaneOutput arrived = next.orElseThrow();\n                        seen.add(arrived);\n                        onOutput.accept(arrived);\n                    } catch (InterruptedException e) {\n                        Thread.currentThread().interrupt();\n                        break;\n                    }\n                }\n            }\n        }\n        return List.copyOf(seen);\n    }\n}\n",
-  "kotlin:examples/src/main/kotlin/io/github/libtmux/examples/WatchWithFlow.kt": "package io.github.libtmux.examples\n\nimport io.github.libtmux.ServerConfig\nimport io.github.libtmux.ServerEndpoint\nimport io.github.libtmux.control.Delivery\nimport io.github.libtmux.kotlin.Server\nimport io.github.libtmux.kotlin.await\nimport io.github.libtmux.kotlin.send\nimport io.github.libtmux.kotlin.sessions\nimport io.github.libtmux.kotlin.withControl\nimport io.github.libtmux.kotlin.withServer\nimport java.nio.file.Path\nimport kotlin.time.Duration\nimport kotlin.time.Duration.Companion.milliseconds\nimport kotlin.time.Duration.Companion.seconds\nimport kotlinx.coroutines.flow.first\nimport kotlinx.coroutines.flow.map\nimport kotlinx.coroutines.runBlocking\nimport kotlinx.coroutines.withTimeoutOrNull\n\n/**\n * Reads a pane's output as a `Flow`, then gives up on a wait by cancelling it.\n *\n * ```\n * java -cp ... io.github.libtmux.examples.WatchWithFlowKt /tmp/libtmux-java-dev/demo/s\n * ```\n */\nfun main(args: Array<String>) {\n    val socket = Path.of(args.getOrElse(0) { \"/tmp/libtmux-java-dev/demo/s\" })\n    runBlocking { println(watchWithFlow(socket, 10.seconds)) }\n}\n\n/**\n * Collects output until the line `echo` printed arrives, then starts a channel wait that nothing\n * will signal and cancels it after a moment. Cancelling ends the coroutine at once and is not a\n * timeout; the tmux client behind the wait is stopped with it.\n *\n * @return one line for each: whether the echo arrived, and whether the wait was cancelled\n */\nsuspend fun watchWithFlow(socket: Path, deadline: Duration): String {\n    val config = ServerConfig.builder().endpoint(ServerEndpoint.socketPath(socket)).build()\n    return withServer(config) { server: Server ->\n        val session = server.sessions().first()\n        withControl(server, session) { control ->\n            // control.output(...) is a cold Flow: the subscription it opens on first collection\n            // closes when collection ends, is cancelled, or throws — nothing to close by hand. The\n            // command goes in onSubscribed: sent before collecting, its output could arrive before\n            // there was a subscription to hold it.\n            val seen = StringBuilder()\n            val echoed =\n                withTimeoutOrNull(deadline) {\n                    control.output(capacity = 32) {\n                        control.send(\"send-keys\", \"-t\", session.name, \"echo flowed\", \"Enter\")\n                    }.map { Delivery.kept(it).data }.first { chunk ->\n                        seen.append(chunk)\n                        WatchPaneOutput.printedLine(seen.toString(), \"flowed\")\n                    }\n                } != null\n\n            val cancelled =\n                withTimeoutOrNull(200.milliseconds) { server.channel(\"never-signalled\").await(30.seconds) } == null\n\n            \"echoed=$echoed\\ncancelled=$cancelled\"\n        }\n    }\n}\n",
-  "lua:examples/native_query.lua": "local query = require(\"libtmux.query\")\n\nlocal schema = {\n    fields = {\n        id = { type = \"string\" },\n        active = { type = \"boolean\" },\n        current_command = { type = \"string\" },\n    },\n}\nlocal rows = {\n    { id = \"%1\", active = true, current_command = \"nvim\" },\n    { id = \"%2\", active = false, current_command = \"sh\" },\n    { id = \"%3\", active = false, current_command = \"vim\" },\n}\nlocal panes = query.select(rows, schema)\nlocal editors = panes:where({ current_command = { one_of = { \"nvim\", \"vim\" } } })\nassert(#editors == 2 and editors[1] == rows[1] and editors[2] == rows[3])\n\nlocal inactive = panes:filter(function(pane)\n    return not pane.active\nend)\nassert(#inactive == 2 and inactive[1].id == \"%2\")\nfor _, pane in ipairs(editors) do\n    print(pane.id, pane.current_command)\nend\n",
-  "lua:examples/quickstart.lua": "local adapter = require(\"libtmux.runtime.luv\")\n\nlocal function must(value, err)\n    if err ~= nil then\n        error(err, 0)\n    end\n    return value\nend\n\nlocal binary = assert(os.getenv(\"TMUX_BIN\"), \"set TMUX_BIN to an absolute tmux executable\")\nlocal socket = assert(os.getenv(\"TMUX_SOCKET\"), \"set TMUX_SOCKET to an explicit socket\")\n\nlocal result = must(adapter.run(function(runtime)\n    local server = must(runtime:connect({ binary = binary, socket_path = socket }):await())\n\n    -- docs:begin main\n    local created = must(\n        server\n            :new_session({ name = \"quickstart\", window_name = \"main\", argv = { \"/bin/sh\" } })\n            :await()\n    )\n    local logs = must(created.session:new_window({ name = \"logs\", argv = { \"/bin/cat\" } }):await())\n    local split =\n        must(logs.pane:split({ direction = \"right\", percent = 40, argv = { \"/bin/cat\" } }):await())\n\n    -- The pane signals through the same tmux binary; a bare `tmux` there may be\n    -- another build that cannot reach this server.\n    local marker = \"libtmux-lua-quickstart\"\n    local signal = (\"printf 'libtmux ready\\\\n'; '%s' wait-for -S %s\"):format(binary, marker)\n    must(created.pane:send_text(signal):await())\n    must(created.pane:send_keys({ \"Enter\" }):await())\n    must(server:command({ \"wait-for\", marker }, { timeout = 10000 }):await())\n\n    local capture = must(created.pane:capture({ history_lines = 20 }):await())\n    assert(must(capture:text()):find(\"libtmux ready\", 1, true), \"pane output was not captured\")\n    print(created.session:reference().id, logs.window:reference().id, split.pane:reference().id)\n\n    must(created.session:kill():await())\n    -- docs:end main\n    must(server:close():await())\n    return true\nend))\n\nassert(result)\n",
-  "lua:examples/snapshot.lua": "local adapter = require(\"libtmux.runtime.luv\")\n\nlocal function must(value, err)\n    if err ~= nil then\n        error(err, 0)\n    end\n    return value\nend\n\nmust(adapter.run(function(runtime)\n    local server = must(runtime\n        :connect({\n            binary = assert(os.getenv(\"TMUX_BIN\"), \"set TMUX_BIN to an absolute tmux executable\"),\n            socket_path = assert(os.getenv(\"TMUX_SOCKET\"), \"set TMUX_SOCKET to an explicit socket\"),\n        })\n        :await())\n    local snapshot = must(server:snapshot({ strict = true }):await())\n    for _, pane in ipairs(snapshot.panes) do\n        io.stdout:write(pane.id, \"\\t\", pane.window_id, \"\\n\")\n    end\n    must(server:close():await())\n    return true\nend))\n",
-  "rs:crates/libtmux/examples/scratch.rs": "//! Build a throwaway session, use it, and leave nothing behind.\n//!\n//! ```console\n//! $ cargo run --example scratch\n//! ```\n\nuse std::time::Duration;\n\nuse libtmux::test::unique_name;\nuse libtmux::{NewWindowOptions, PaneWait, Server, SplitDirection, SplitOptions};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    // An example must not build sessions on whatever server the reader\n    // happens to be using, so this one gets a socket of its own. More than one\n    // libtmux runs on a developer's machine, so it goes in a directory this\n    // one owns rather than straight into the temporary directory.\n    let root = std::path::Path::new(\"/tmp/libtmux-rs-dev\");\n    std::fs::create_dir_all(root)?;\n    let socket = root.join(format!(\"{}.sock\", unique_name(\"libtmux-scratch\")));\n    let server = Server::builder().socket_path(&socket).build()?;\n\n    // The scope kills the session whether the body succeeds or fails, so a\n    // failure partway through does not leave a session behind.\n    println!(\"server on {}\", socket.display());\n\n    let output = server\n        .with_session(unique_name(\"scratch\").as_str(), async |session| {\n            println!(\"  session {} created\", session.id());\n\n            let window = session\n                .new_window(NewWindowOptions::new(\"work\").command(\"sh\"))\n                .await?;\n            println!(\"  window {} running sh\", window.id());\n\n            window\n                .split(SplitOptions::new(SplitDirection::Below).command(\"sh\"))\n                .await?;\n            println!(\"  split it: {} panes\", window.panes().await?.len());\n\n            // A window always has an active pane, but saying so with a panic\n            // would be a worse example than handling it.\n            let Some(pane) = window.active_pane().await? else {\n                return Ok(0);\n            };\n            println!(\"  typing into {}\", pane.id());\n            pane.send_line(\"printf 'hello from tmux\\\\n'\").await?;\n\n            // tmux runs the shell asynchronously, so wait for the output\n            // rather than sleeping and hoping. The outcome is checked because\n            // a wait that reached its deadline still returns successfully.\n            match pane.wait_for_text(\"hello\", Duration::from_secs(5)).await? {\n                PaneWait::Arrived => println!(\"  the pane printed it\"),\n                other => println!(\"  gave up: {other:?}\"),\n            }\n\n            // region: capture\n            let lines = pane.capture().await?;\n            for line in lines.iter().filter(|line| !line.as_bytes().is_empty()) {\n                println!(\"  | {}\", line.to_string_lossy());\n            }\n            // endregion\n\n            Ok::<_, Box<dyn std::error::Error>>(lines.len())\n        })\n        .await?;\n\n    println!(\"captured {output} lines, then the scope killed the session\");\n\n    // The lenient form is the one that answers this question. The scope killed\n    // the only session, so tmux exited with it, and the loud form reports that\n    // as the failure it is rather than as the empty listing this is asking for.\n    assert!(\n        server.sessions().await.unwrap_or_default().is_empty(),\n        \"the scope cleaned up\",\n    );\n\n    println!(\n        \"sessions left behind: {}\",\n        server.sessions().await.unwrap_or_default().len()\n    );\n\n    server.shutdown().await?;\n\n    // tmux does not unlink its socket when the server exits, so whatever named\n    // one owns removing it. Leaving it behind is invisible until /tmp fills up.\n    std::fs::remove_file(&socket)?;\n    Ok(())\n}\n",
-  "rs:crates/tmux-mcp/examples/readonly.rs": "//! Serve tmux over MCP, offering only the inspect toolset.\n//!\n//! The shipped binary reads `LIBTMUX_TOOLSETS` at startup. Building the server\n//! yourself is how you decide it in code instead, which is\n//! what you want when the surface is a property of the program rather than of\n//! how someone launched it.\n//!\n//! ```console\n//! $ cargo run --example readonly\n//! ```\n//!\n//! Then talk MCP to it on stdin and stdout.\n\nuse libtmux::Server;\nuse rmcp::ServiceExt as _;\nuse rmcp::transport::stdio;\nuse tmux_mcp::{Selection, TmuxTools};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let tools = TmuxTools::builder(Server::new()?)\n        .selection(Selection::parse(Some(\"inspect\"), None, None)?)\n        .build();\n\n    // stdout carries the protocol, so this goes to stderr.\n    eprintln!(\"serving {} inspect tools\", tools.offered().len());\n\n    tools.serve(stdio()).await?.waiting().await?;\n    Ok(())\n}\n",
-  "ruby:examples/async_cancel.rb": "# frozen_string_literal: true\n\nrequire \"libtmux/async\"\nrequire_relative \"support\"\n\nExample.run(\"async_cancel\") do |server|\n  server.new_session(name: \"async\", command: [\"/bin/cat\"])\n  # docs:begin main\n  Async do |parent|\n    LibTmux::Async.open(parent: parent, server: server) do |scope|\n      waiting = parent.async do\n        scope.server.run([\"wait-for\", \"-S\", \"ready\", \";\", \"wait-for\", \"held\"], timeout: 0.5)\n      rescue LibTmux::Cancelled => error\n        error\n      end\n      scope.server.wait_for(\"ready\", timeout: 0.5)\n      Example.check(scope.diagnostics.fetch(:active_process_slots) == 1, \"waiting client lost its slot\")\n      captures = scope.map(scope.server.list_panes.map(&:ref), concurrency: 2) do |ref|\n        scope.server.pane(ref).capture\n      end\n      Example.check(captures.all?(&:success?), \"sibling captures stalled\")\n      waiting.cancel\n      failure = waiting.wait\n      Example.check(failure.is_a?(LibTmux::Cancelled), \"cancellation lost\")\n      Example.check(failure.delivery == :possibly_sent, \"cancelled dispatch claimed no effects\")\n      Example.raises(Errno::ECHILD) { Process.waitpid(failure.pid, Process::WNOHANG) }\n      Example.check(scope.server.diagnostics.fetch(:admitted_requests).zero?, \"cancelled client remains admitted\")\n    end\n  end.wait\n  # docs:end main\nend\n",
-  "ruby:examples/quickstart.rb": "# frozen_string_literal: true\n\nrequire_relative \"support\"\nrequire \"stringio\"\n\noriginal_stdout = $stdout\noutput = StringIO.new\n$stdout = output\n\nbegin\n  # docs:begin main\n  require \"libtmux\"\n\n  snapshot = LibTmux::Server.start do |server|\n    session = server.new_session(name: \"work\", window_name: \"main\", command: [\"/bin/cat\"])\n    window = session.new_window(name: \"logs\", command: [\"/bin/cat\"])\n    window.split(direction: :horizontal, size: \"40%\", command: [\"/bin/cat\"])\n\n    server.snapshot\n  end\n\n  snapshot.windows.each do |window|\n    puts \"#{window.name}: #{window.panes.map(&:id).join(', ')}\"\n  end\n  # docs:end main\n\n  # docs:begin queries\n  panes = snapshot.panes\n  active_ids = panes.where(active: true).map(&:id)\n  wide_panes = panes.select { |pane| pane.width >= 40 }\n  panes_by_window = panes.group_by { |pane| pane.window.name }\n\n  logs = snapshot.windows.one(name: \"logs\")\n  missing = snapshot.windows.one_or_nil(name: \"missing\")\n  # docs:end queries\n\n  Example.check(output.string == \"main: %0\\nlogs: %1, %2\\n\", \"unexpected window listing\")\n  Example.check(panes.size == 3 && active_ids.size == 2, \"unexpected pane selection\")\n  Example.check(wide_panes.map(&:id) == panes.where(width: {gte: 40}).map(&:id), \"block selection differs\")\n  Example.check(panes_by_window.transform_values(&:size) == {\"main\" => 1, \"logs\" => 2}, \"unexpected pane groups\")\n  Example.check(logs.panes.size == 2 && missing.nil?, \"unexpected exact lookup\")\nensure\n  $stdout = original_stdout\nend\n\nputs(ENV[\"LIBTMUX_EXAMPLE_INSTALLED\"] ? \"PASS quickstart\" : output.string)\n",
-  "scala:examples/src/main/scala/io/github/libtmux/scaladsl/examples/BlockingWorkspace.scala": "package io.github.libtmux.scaladsl.examples\n\nimport io.github.libtmux.{Layout, ServerConfig, SessionSpec, SplitSpec}\n// Wildcards, not named imports: examples lives beside io.github.libtmux.scaladsl, not inside it, so\n// its generated and handwritten extension methods (isAlive, newSession, session, ...) need an\n// explicit import rather than the enclosing-package visibility a nested package would get for free.\nimport io.github.libtmux.scaladsl.*\nimport io.github.libtmux.scaladsl.query.*\nimport scala.concurrent.duration._\nimport scala.util.Using\n\n/** Builds a small workspace with the direct-style facade: a session with a\n  * split window, queried with the typed field DSL, then torn down. Every handle\n  * here is an opaque alias of the Java one — `server.newSession(...)` returns\n  * the same object `io.github.libtmux.Server.newSession` would, with a\n  * generated Scala-shaped signature.\n  */\nobject BlockingWorkspace {\n  def main(arguments: Array[String]): Unit = run(\n    ExampleRuntime.config(arguments)\n  )\n\n  def run(config: ServerConfig): Unit = Using.resource(Server.open(config)) {\n    server =>\n      require(server.isAlive(), \"example requires an existing tmux server\")\n      val name = ExampleRuntime.name(\"scala-blocking\")\n      val session = server.newSession(\n        SessionSpec.builder().named(name).running(\"/bin/sh\").build()\n      )\n      try {\n        val window = session.windows.head\n        val shell = window.panes.head\n        val second = window.split(SplitSpec.builder().running(\"cat\").build())\n        window.selectLayout(Layout.EVEN_HORIZONTAL)\n        shell.select()\n\n        shell.sendLine(\"printf 'line-%s\\\\n' submitted\")\n        assert(\n          !shell\n            .awaitText(\"line-submitted\", 5.seconds)\n            .equals(io.github.libtmux.TextOutcome.TIMED_OUT)\n        )\n        val screen = shell.capture()\n        assert(screen.exists(_.contains(\"line-submitted\")))\n\n        // The typed field DSL: Pane.command/.active on the handle's own companion, .matching as a\n        // local filter, exactlyOne for strict cardinality.\n        val panes = Vector(shell, second)\n        assert(\n          panes\n            .matching(Pane.active.is(true) || Pane.active.is(false))\n            .size == 2\n        )\n        val onlyShell = panes.matching(Pane.id.is(shell.info.id.value()))\n        assert(onlyShell.exactlyOne.equals(Right(shell)), onlyShell)\n        assert(server.session(name + \"-missing\").isEmpty)\n      } finally session.kill()\n      assert(server.isAlive())\n  }\n}\n",
-  "swift:Examples/Sources/ExampleCode/Changing.swift": "// The examples in the README's \"Change what is there\" section.\n\nimport LibTmux\n\npublic func buildASessionByHand(_ server: Server) async throws -> Pane {\n    let session = try await server.newSession(named: \"work\", windowName: \"editor\")\n    _ = try await server.setOption(\"@purpose\", to: \"development\", scope: .session(session))\n    let logs = try await server.newWindow(in: session, named: \"logs\").window\n    let pane = try await server.splitWindow(logs, direction: .right)\n    try await server.run(\"tail -f /tmp/build.log\", in: pane)\n    return pane\n}\n\npublic func readBackWhatAPanePrinted(_ server: Server, _ pane: Pane) async throws -> [String] {\n    let lines = try await server.capture(pane)\n    print(lines.suffix(5).joined(separator: \"\\n\"))\n    return lines\n}\n\npublic func spendOneProcessOnAllOfIt(_ server: Server) async throws {\n    var plan = TmuxCommandList()\n    for name in [\"edit\", \"test\", \"logs\"] {\n        plan = plan.then(\"new-window\", [\"-d\", \"-n\", name])\n    }\n    _ = try await server.run(plan)\n}\n",
-  "swift:Examples/Sources/ExampleCode/MCPEmbedding.swift": "import LibTmux\nimport LibTmuxMCP\n\npublic func useEmbeddedTools(on server: Server) async throws(ToolError) -> Int {\n    let tools = TmuxTools(server: server)\n    for definition in tools.visibleDefinitions {\n        print(definition.name, definition.summary)\n    }\n    let result = try await tools.call(ToolCall(name: \"list_panes\"))\n    return result.structured[\"panes\"]?.arrayValue?.count ?? 0\n}\n\npublic func useExactEmbeddedTools(on server: Server) -> TmuxTools {\n    let authority = ToolAuthority(\n        toolsets: [],\n        includedTools: [\"create_window\", \"list_sessions\"]\n    )\n    let tools = TmuxTools(server: server, authority: authority)\n    return tools\n}\n",
-  "swift:Examples/Sources/ExampleCode/Waiting.swift": "// The examples in <doc:Waiting>, and the waiting section of the README.\n\nimport LibTmux\n\npublic func waitingOnAChannel(_ server: Server, pane: Pane) async throws {\n    // region: guides-capturing-output-176\n    try await server.run(\n        \"make; \\(server.shellInvocation) wait-for -S built\",\n        in: pane\n    )\n    try await server.wait(for: \"built\")\n    // endregion\n}\n\npublic func watchingAFormat(_ server: Server, pane: Pane) async throws -> String? {\n    try await server.connected(attachingTo: \"work\") { server, control in\n        try await control.watch(\n            FormatSubscription(\n                name: \"cmd\",\n                scope: .pane(pane.id),\n                format: \"#{pane_current_command}\"\n            )\n        )\n        for try await change in control.changes(named: \"cmd\") {\n            return change.value\n        }\n        return nil\n    }\n}\n\npublic func waitingOnOutput(\n    _ server: Server,\n    pane: Pane\n) async throws -> OutputWait {\n    let ready = try RegexPattern(\"Listening on\")\n    let failed = try RegexPattern(\"EADDRINUSE|error\", options: [.caseInsensitive])\n    let waited = try await server.waitForOutput(\n        in: pane,\n        matching: [ready],\n        stoppingAt: [failed]\n    )\n    return waited\n}\n\npublic func watchingForChanges(\n    _ server: Server,\n    pane: Pane,\n    building: Bool\n) async throws {\n    var mark = try await server.capture(pane, since: nil).cursor\n    while building {\n        let update = try await server.capture(pane, since: mark)\n        for line in update.lines { print(line) }\n        mark = update.cursor\n    }\n}\n",
-  "swift:Examples/Sources/ExampleCode/Workspaces.swift": "// The examples in the README's `WorkspaceBuilder` section.\n\nimport Foundation\nimport LibTmux\nimport TmuxWorkspace\n\npublic func describeAWorkspaceInSwift() -> Workspace {\n    let workspace = Workspace(\n        sessionName: \"work\",\n        windows: [\n            WindowPlan(\n                windowName: \"editor\",\n                layout: \"even-horizontal\",\n                panes: [PanePlan(), PanePlan()]\n            ),\n            WindowPlan(\n                windowName: \"logs\",\n                panes: [PanePlan(shellCommands: [\"tail -f /tmp/build.log\"])]\n            ),\n        ]\n    )\n    return workspace\n}\n\npublic func buildItOnAServer(_ server: Server, _ workspace: Workspace) async throws -> Session {\n    let session = try await WorkspaceBuilder.build(workspace, on: server)\n    print(session.name, session.windowCount)\n    return session\n}\n\npublic func readAWorkspaceWrittenAsJSON(_ json: Data) throws -> Workspace {\n    try Workspace.decode(json: json)\n}\n\n// Deliberately NOT wrapped in `#if YAMLWorkspaces`. A trait defines its\n// compilation condition only inside the package that declares it, so that guard\n// in a consumer package is always false and deletes the example — loudly if a\n// test calls it, silently if nothing does. The symbol is nonetheless here,\n// because the dependency was resolved with the trait on.\npublic func readATmuxpFile(_ text: String) throws -> Workspace {\n    try Workspace.decode(yaml: text)\n}\n",
-  "ts:examples/agent/agent.ts": "import type { Server } from \"libtmux/server\";\n\n/**\n * Drive tmux the way an agent does: act, then wait for the result.\n *\n * One control observer carries notifications while commands use the server's\n * engine. Keeping the observer open makes event-driven waits persistent; it\n * does not turn command output into a control-mode protocol.\n */\nexport async function runAndWait(server: Server, command: string, marker: string): Promise<string> {\n  // A connection attaches, so the session has to exist first. On a server with\n  // none, `connect()` fails saying exactly that.\n  const session = await server.newSession({ name: \"agent\" });\n\n  await using live = await server.connect({ target: session.id });\n\n  const pane = (await live.snapshot()).sessions.one({ id: session.id }).panes.one();\n\n  // Subscribe before acting. A marker printed between the command and the\n  // subscription is one nobody is listening for, and the wait never ends.\n  const printed = live\n    .subscribe()\n    .find(\n      (event) => event.kind === \"output\" && event.paneId === pane.id && event.data.includes(marker),\n      { timeoutMs: 30_000 },\n    );\n\n  await pane.sendKeys(command);\n\n  const event = await printed;\n  if (event === undefined) throw new Error(`${command} never printed ${marker}`);\n  return event.kind === \"output\" ? event.data : \"\";\n}\n\n/**\n * Wait for the server to reach a shape, rather than for one event.\n *\n * `waitFor` reads the server, then re-reads on each notification, so it returns\n * at once when the condition already holds and does not miss a change that\n * lands while it is subscribing.\n */\nexport async function buildAndSettle(server: Server, windows: readonly string[]): Promise<number> {\n  const session = await server.newSession({ name: \"settling\" });\n  await using live = await server.connect({ target: session.id });\n\n  const bound = (await live.snapshot()).sessions.one({ id: session.id });\n  for (const name of windows) {\n    // eslint-disable-next-line no-await-in-loop -- window order is observable.\n    await bound.newWindow({ name });\n  }\n\n  const settled = await live.waitFor(\n    (snapshot) => windows.every((name) => snapshot.windows.exists({ name })),\n    { timeoutMs: 30_000 },\n  );\n\n  return settled.windows.count({ session: { is: { id: session.id } } });\n}\n",
-  "ts:examples/capture/capture.ts": "import type { Server } from \"libtmux\";\n\n/**\n * Move text through a tmux buffer, and read what a pane is showing.\n *\n * The half of orchestration that is not making things happen. A named buffer\n * is tmux's own clipboard: anything in it can be pasted into any pane on the\n * server, by this process or by a person at the keyboard, without the text\n * passing through your program a second time.\n */\nexport async function moveTextThroughABuffer(\n  server: Server,\n  text: string,\n): Promise<{ named: readonly string[]; roundTripped: readonly string[] }> {\n  // tmux stores nothing for empty text and reports success, so a buffer whose\n  // content is computed has to be checked before it is written — otherwise the\n  // name is absent and the next call to read it is what fails.\n  if (text === \"\") throw new Error(\"tmux holds no empty buffer\");\n\n  await server.setBuffer(\"report\", text);\n  const roundTripped = await server.showBuffer(\"report\");\n  const named = await server.listBuffers();\n\n  // Buffers outlive the program that made them.\n  await server.deleteBuffer(\"report\");\n  return { named, roundTripped };\n}\n\n/**\n * What a pane is showing, scrollback included.\n *\n * `start` counts back from the visible top, so -100 asks for the last hundred\n * lines or as many as exist. A pane that has printed nothing answers with\n * nothing rather than with blank lines.\n */\nexport async function readPane(server: Server): Promise<readonly string[]> {\n  const session = await server.newSession({ name: \"capture\" });\n  const pane = session.activePane;\n  if (pane === undefined) throw new Error(\"a new session always has one pane\");\n  return pane.capture({ start: -100 });\n}\n",
-  "ts:examples/quickstart/quickstart.ts": "import { Server, TmuxCommandError, type ServerSnapshot } from \"libtmux\";\n\n/**\n * A runnable tour of the API, driven by the tests so it cannot rot.\n *\n * Every step here appears in README.md.\n */\nexport async function quickstart(server: Server): Promise<ServerSnapshot> {\n  // Nothing is read until you ask. `snapshot()` is the only step that talks to\n  // tmux; everything reachable from it resolves locally.\n  const session = await server.newSession({ name: \"quickstart\" });\n  const editor = await session.newWindow({ name: \"editor\" });\n  await editor.split();\n\n  const snapshot = await server.snapshot();\n\n  // Declarative filtering, serializable and stable on the wire.\n  const found = snapshot.windows.where({ name: \"editor\" }).one();\n\n  // Relations are plain properties: no await, no tmux command.\n  const paneCount = found.panes.length;\n  if (paneCount !== 2) throw new Error(`expected two panes, saw ${String(paneCount)}`);\n\n  // A criterion is spelled like the handle accessor it filters.\n  if (snapshot.panes.count({ currentCommand: { contains: \"\" } }) === 0) {\n    throw new Error(\"expected panes to report a current command\");\n  }\n  const first = found.panes.at(0);\n  if (first === undefined) throw new Error(\"expected a pane\");\n  await first.sendKeys(\"echo hello-from-libtmux\", { literal: true });\n\n  // Failures carry their parts rather than a formatted sentence.\n  try {\n    await server.setOption(\"not-a-real-option\", \"1\");\n  } catch (error) {\n    if (!(error instanceof TmuxCommandError)) throw error;\n    if (error.args[0] !== \"set-option\") throw error;\n  }\n\n  return snapshot;\n}\n",
-  "ts:examples/workspace/workspace.ts": "import type { Server } from \"libtmux/server\";\nimport type { Session } from \"libtmux/session\";\nimport { applyWorkspace } from \"@libtmux/workspace\";\nimport type { WorkspaceInput } from \"@libtmux/workspace/config\";\n\n/**\n * Build the shape most people reach for tmux to get: one session, a window\n * per concern, each pane already running the thing it is there for.\n *\n * `server.batch` plans several windows and resolves them from one final\n * snapshot. `buildWorkspace`, below, delegates declared topology to the\n * workspace package instead of maintaining another reconciler here.\n */\nexport async function buildSimpleWorkspace(server: Server): Promise<Session> {\n  const built = await server.newSession({\n    name: \"work\",\n    shellCommand: \"sleep 30\",\n    windowName: \"editor\",\n  });\n\n  const [logs, shell] = await server.batch([\n    built.plan.newWindow({ name: \"logs\", shellCommand: \"tail -f /dev/null\" }),\n    built.plan.newWindow({ name: \"shell\" }),\n  ]);\n\n  await logs.selectLayout(\"even-horizontal\");\n  void shell.name; // \"shell\"\n\n  return built;\n}\n\nexport const DEVELOPMENT_WORKSPACE = {\n  session_name: \"workspace-example\",\n  windows: [\n    { panes: [\"sleep 30\", \"sleep 30\"], window_name: \"editor\" },\n    { panes: [\"sleep 30\"], window_name: \"server\" },\n    { window_name: \"logs\" },\n  ],\n} satisfies WorkspaceInput;\n\n/** Apply the package's declarative workspace to a server. */\nexport function buildWorkspace(server: Server): Promise<Session> {\n  return applyWorkspace(server, DEVELOPMENT_WORKSPACE);\n}\n\n/**\n * Tear a workspace down without caring whether it is there.\n *\n * Killing a session that has already gone is not a failure worth propagating,\n * which is the one case worth handling separately from every other tmux error.\n */\nexport async function removeWorkspace(server: Server, name: string): Promise<boolean> {\n  const found = (await server.snapshot()).sessions.first({ name });\n  if (found === undefined) return false;\n  await found.kill();\n  return true;\n}\n"
+  "dotnet:examples/LibTmux.Examples/Snippets/OneShot.cs": {
+    "repository": "libtmux/libtmux-dotnet",
+    "revision": "320dc64f4b8b7815842471327a5e6b84a1499bf8",
+    "sha256": "a99b447bf8716408758af66c9ed70d931c85adf2e1703cc4a9ff5e43f914ee03",
+    "content": "using System.Runtime.Versioning;\n\nnamespace LibTmux.Examples.Snippets;\n\n/// <summary>The default mode: one command, one client, one materialized object.</summary>\n[UnsupportedOSPlatform(\"windows\")]\npublic static class OneShot\n{\n    /// <summary>Connects, builds a hierarchy, and types into the pane it made.</summary>\n    [Example(\"Connect, build a session and window, and type into a pane\")]\n    public static async Task ConnectAndBuild()\n    {\n        #region ConnectAndBuild\n        // Requires a tmux server already listening on this socket:\n        // ConnectAsync() discovers one, it never starts one. With nothing\n        // running yet, call Server.CreateOwnedAsync() instead.\n        Server server = await Server.ConnectAsync();\n        Session session = await server.CreateSessionAsync(new NewSessionRequest { Name = \"build\" });\n        Window window = await session.CreateWindowAsync(new NewWindowRequest { Name = \"tests\" });\n        Pane pane = (await window.GetPanesAsync())[0];\n\n        await pane.SendTextAsync(\"dotnet test\");\n        #endregion\n    }\n\n    /// <summary>Creates a window and prints what tmux answered about it.</summary>\n    [Example(\"One command, one materialized window\")]\n    public static async Task CreateWindow(Session session, CancellationToken ct)\n    {\n        #region CreateWindow\n        Window window = await session.CreateWindowAsync(new NewWindowRequest { Name = \"build\" }, ct);\n        Console.WriteLine($\"{window.Id} {window.Index}:{window.Name}\");\n        #endregion\n    }\n}\n"
+  },
+  "fsharp:examples/LibTmux.FSharp.Quickstart/Program.fs": {
+    "repository": "libtmux/libtmux-dotnet",
+    "revision": "a62d9a57148e18f070514cd900d8875c4fdb09d7",
+    "sha256": "138b2b7312f0fd7a425fa2eb3934a4f44522f3de1bef9f38471f72bfab9e70d7",
+    "content": "// fsharp-snippet: Quickstart\nopen System\nopen System.Threading\nopen LibTmux\nopen LibTmux.FSharp\n\nlet runAsync () =\n    task {\n        let binary =\n            match Environment.GetEnvironmentVariable(\"LIBTMUX_TMUX\") with\n            | null\n            | \"\" -> \"tmux\"\n            | value -> value\n\n        let options =\n            ServerConnectionOptions(\n                SocketName = \"fsharp-\" + Guid.NewGuid().ToString(\"N\"),\n                ConfigurationFile = \"/dev/null\",\n                TmuxBinaryPath = binary\n            )\n\n        use! ownedServer = LibTmux.Server.CreateOwnedAsync(options, CancellationToken.None)\n\n        use! _ownedSession =\n            ownedServer.Value.CreateOwnedSessionAsync(\n                NewSessionRequest(Name = \"demo\", WindowName = \"shell\", Command = \"/bin/sh\"),\n                CancellationToken.None\n            )\n\n        use! _ownedWorker =\n            ownedServer.Value.CreateOwnedSessionAsync(\n                NewSessionRequest(Name = \"worker\", WindowName = \"idle\", Command = \"/bin/sh\"),\n                CancellationToken.None\n            )\n\n        let! connected = LibTmux.Server.ConnectAsync(options, CancellationToken.None)\n\n        let! captured =\n            connected |> Server.capture CancellationToken.None SnapshotDepth.Panes\n\n        let session =\n            captured.Sessions |> Seq.find (fun candidate -> candidate.Name = \"demo\")\n\n        let window = session.Windows |> Seq.exactlyOne\n        let pane = window.Panes |> Seq.exactlyOne\n\n        let command =\n            pane\n            |> Pane.currentCommand\n            |> Option.defaultWith (fun () -> failwith \"The captured pane has no command.\")\n\n        let localMatches =\n            captured.Panes\n            |> Seq.filter (fun candidate -> candidate.Id = pane.Id)\n            |> Seq.length\n\n        let hasPane =\n            Filter.eq pane.Id PaneFields.id\n            |> Filter.any WindowFields.panes\n            |> Filter.any SessionFields.windows\n\n        let selected =\n            captured.Sessions\n            |> Query.matching hasPane\n            |> Selection.exactlyOne\n            |> Result.defaultWith (fun error -> failwithf \"Expected one matching session: %A\" error)\n\n        if\n            captured.Sessions.Count <> 2\n            || captured.Panes.Count <> 2\n            || window.Name <> \"shell\"\n            || localMatches <> 1\n            || selected.Id <> session.Id\n        then\n            failwith \"The captured graph and portable filter did not agree.\"\n\n        printfn \"%s / %s / %s\" session.Name window.Name command\n        printfn \"local pane matches: %d\" localMatches\n        printfn \"portable match: %s\" selected.Name\n    }\n\nrunAsync().GetAwaiter().GetResult()\n// endfsharp-snippet\n"
+  },
+  "go:examples/quickstart/main.go": {
+    "repository": "libtmux/libtmux-go",
+    "revision": "bb06e26e116e941813ca40bf45e7e3a47d38f52a",
+    "sha256": "28725dec488dc4b80ef9812d328f1df2fce947d975ac6fc406e8bea85670545a",
+    "content": "// Command quickstart demonstrates a complete session, window, and pane lifecycle.\npackage main\n\nimport (\n\t\"bufio\"\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"log\"\n\t\"time\"\n\n\t\"github.com/libtmux/libtmux-go/tmux\"\n)\n\nfunc main() {\n\tif err := start(); err != nil {\n\t\tlog.Fatal(err)\n\t}\n}\n\n// start owns cleanup because log.Fatal skips deferred calls in main.\nfunc start() error {\n\tctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)\n\tdefer cancel()\n\n\tserver, err := tmux.NewServer(tmux.ServerOptions{})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"configure tmux server: %w\", err)\n\t}\n\treturn run(ctx, server)\n}\n\n// run accepts injected server state so tests can isolate the example.\nfunc run(ctx context.Context, server tmux.Server) (err error) {\n\t// docs:quickstart given:ctx context.Context; server tmux.Server\n\tsession, err := server.NewSession(ctx, tmux.NewSessionRequest{\n\t\tName: \"libtmux-go-quickstart\", WindowName: \"start\",\n\t})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create session: %w\", err)\n\t}\n\tdefer func() {\n\t\tcleanupCtx, cleanupCancel := context.WithTimeout(context.WithoutCancel(ctx), time.Second)\n\t\tdefer cleanupCancel()\n\t\terr = errors.Join(err, session.Kill(cleanupCtx))\n\t}()\n\n\twindow, err := session.NewWindow(ctx, tmux.NewWindowRequest{Name: new(\"work\")})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create window: %w\", err)\n\t}\n\tpane, err := window.SplitPane(ctx, tmux.SplitPaneRequest{\n\t\tDirection: tmux.PaneDirectionRight, Command: \"sh\",\n\t})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"split window: %w\", err)\n\t}\n\toutput, err := pane.OpenObservation(ctx)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"watch pane: %w\", err)\n\t}\n\tdefer func() { err = errors.Join(err, output.Close()) }()\n\tif _, err := fmt.Fprintln(pane.Writer(ctx), \"printf 'libtmux ready\\\\n'\"); err != nil {\n\t\treturn fmt.Errorf(\"send command: %w\", err)\n\t}\n\t// docs:end\n\n\tscanner := bufio.NewScanner(output.Reader(ctx))\n\tfor scanner.Scan() {\n\t\tif scanner.Text() == \"libtmux ready\" {\n\t\t\tfmt.Println(\"libtmux ready\")\n\t\t\treturn nil\n\t\t}\n\t}\n\treturn fmt.Errorf(\"read pane: %w\", scanner.Err())\n}\n"
+  },
+  "go:workspace/example_test.go": {
+    "repository": "libtmux/libtmux-go",
+    "revision": "bb06e26e116e941813ca40bf45e7e3a47d38f52a",
+    "sha256": "2eaaf9c21bb471139af18b70585554b61ca0463b16486984e5aa4ecbc8368e8b",
+    "content": "package workspace_test\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"time\"\n\n\t\"github.com/libtmux/libtmux-go/tmux\"\n\t\"github.com/libtmux/libtmux-go/workspace\"\n)\n\n// Load a tmuxp-style document and build the session it describes.\nfunc Example() {\n\tctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)\n\tdefer cancel()\n\tserver, err := tmux.NewServer(tmux.ServerOptions{\n\t\tSocketName: \"libtmux-go-example-workspace\",\n\t})\n\tif err != nil {\n\t\tfmt.Println(\"server:\", err)\n\t\treturn\n\t}\n\tdefer killExampleServer(server)\n\n\tdocument := []byte(`\nsession_name: review\nwindows:\n  - window_name: editor\n    panes:\n      - shell_command: printf 'ready\\n'\n  - window_name: tests\n    panes:\n      - shell_command: printf 'ready\\n'\n      - shell_command: printf 'ready\\n'\n`)\n\tparsed, err := workspace.Parse(document)\n\tif err != nil {\n\t\tfmt.Println(\"parse:\", err)\n\t\treturn\n\t}\n\n\tsession, err := workspace.Build(ctx, server, parsed)\n\tif err != nil {\n\t\tfmt.Println(\"build:\", err)\n\t\treturn\n\t}\n\n\tname, _ := session.Name()\n\twindows, err := session.SearchWindows(ctx, nil)\n\tif err != nil {\n\t\tfmt.Println(\"search windows:\", err)\n\t\treturn\n\t}\n\tfmt.Println(name, len(windows))\n\t// Output: review 2\n}\n\n// Create the initial session, prefer a retained connection where tmux supports\n// one, then populate the rest of the workspace through that session.\nfunc ExampleBuildInto() {\n\tctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)\n\tdefer cancel()\n\tserver, err := tmux.NewServer(tmux.ServerOptions{\n\t\tSocketName: \"libtmux-go-example-workspace-continue\",\n\t})\n\tif err != nil {\n\t\tfmt.Println(\"server:\", err)\n\t\treturn\n\t}\n\tdefer killExampleServer(server)\n\n\tdescribed := workspace.Workspace{\n\t\tSessionName: \"review\",\n\t\tWindows: []workspace.Window{\n\t\t\t{Name: \"editor\", Panes: []workspace.Pane{{Shell: \"sleep 60\"}}},\n\t\t\t{Name: \"tests\", Panes: []workspace.Pane{{Shell: \"sleep 60\"}}},\n\t\t},\n\t}\n\trequest, err := described.InitialSessionRequest()\n\tif err != nil {\n\t\tfmt.Println(\"request:\", err)\n\t\treturn\n\t}\n\t_, connection, err := server.NewSessionConnection(\n\t\tctx,\n\t\trequest,\n\t\ttmux.ConnectionOptions{},\n\t)\n\tif err != nil {\n\t\tfmt.Println(\"create:\", err)\n\t\treturn\n\t}\n\tdefer func() { _ = connection.Close() }()\n\tsession := connection.Session()\n\tif err := workspace.BuildInto(ctx, session, described); err != nil {\n\t\tfmt.Println(\"build:\", err)\n\t\treturn\n\t}\n\twindows, err := session.SearchWindows(ctx, nil)\n\tif err != nil {\n\t\tfmt.Println(\"search windows:\", err)\n\t\treturn\n\t}\n\tfmt.Println(len(windows))\n\t// Output: 2\n}\n\n// A misspelled key fails the parse rather than being dropped, so a workspace\n// that does not do what its author meant says so before anything is built.\nfunc ExampleParse_unknownField() {\n\t_, err := workspace.Parse([]byte(\"session_name: review\\nwindow:\\n  - {}\\n\"))\n\tfmt.Println(err != nil)\n\t// Output: true\n}\n\n// killExampleServer stops an example's server on a context of its own, since an\n// example's own context may already be spent by the time it returns.\nfunc killExampleServer(server tmux.Server) {\n\tctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\n\tdefer cancel()\n\t_ = server.Kill(ctx)\n}\n"
+  },
+  "java:examples/src/main/java/io/github/libtmux/examples/BuildAWorkspace.java": {
+    "repository": "libtmux/libtmux-java",
+    "revision": "842228310449e879ebcaa3f910597757c9dbffd6",
+    "sha256": "7916cdfd67e4922fdbe79969fa0bd04bc6b0965dfb36df41e9a935bedfa590a3",
+    "content": "package io.github.libtmux.examples;\n\nimport io.github.libtmux.Layout;\nimport io.github.libtmux.Pane;\nimport io.github.libtmux.Server;\nimport io.github.libtmux.ServerConfig;\nimport io.github.libtmux.ServerEndpoint;\nimport io.github.libtmux.ServerNotRunningException;\nimport io.github.libtmux.Session;\nimport io.github.libtmux.Window;\nimport java.nio.file.Path;\nimport java.util.Optional;\n\n/**\n * Lays out a session the way you would set one up by hand before starting work.\n *\n * <pre>{@code\n * java BuildAWorkspace.java /tmp/libtmux-java-dev/demo/s\n * }</pre>\n */\npublic final class BuildAWorkspace {\n\n    private BuildAWorkspace() {}\n\n    public static void main(String[] args) {\n        run(Path.of(args.length > 0 ? args[0] : \"/tmp/libtmux-java-dev/demo/s\"));\n    }\n\n    /** Separated from {@code main} so the suite can run exactly what a reader runs. */\n    public static String run(Path socket) {\n        ServerConfig config = ServerConfig.builder()\n                .endpoint(ServerEndpoint.socketPath(socket))\n                .configFile(Path.of(\"/dev/null\"))\n                .build();\n\n        // Closing a server closes this client. The tmux server, and the session, outlive the program\n        // — which is the whole point of tmux and the reason nothing here kills it.\n        try (Server server = Server.open(config)) {\n            // One read decides and answers. An absent daemon means the name cannot be taken, so\n            // that specific failure is the other way this resolves to \"not found\".\n            Optional<Session> existing;\n            try {\n                existing = server.session(\"work\");\n            } catch (ServerNotRunningException absent) {\n                existing = Optional.empty();\n            }\n            Session session = existing.orElseGet(() -> server.newSession(\"work\"));\n\n            Window editor = session.newWindow(window -> window.named(\"editor\").detached());\n            Pane shell = editor.split(split -> split.toRight());\n            shell.sendLine(\"git status --short\");\n\n            editor.selectLayout(Layout.MAIN_VERTICAL);\n\n            return \"session \" + session.name() + \" has \"\n                    + session.refresh().windows().size() + \" windows\";\n        }\n    }\n}\n"
+  },
+  "kotlin:examples/src/main/kotlin/io/github/libtmux/examples/WatchWithFlow.kt": {
+    "repository": "libtmux/libtmux-java",
+    "revision": "3c9ad0ee5698554b9311b3fbc63d3e33873830c6",
+    "sha256": "c6ba53d7c749f5b9af12ed2fa6f544c997baac371246e777c1ba4fb8139d4e05",
+    "content": "package io.github.libtmux.examples\n\nimport io.github.libtmux.ServerConfig\nimport io.github.libtmux.ServerEndpoint\nimport io.github.libtmux.control.Delivery\nimport io.github.libtmux.kotlin.Server\nimport io.github.libtmux.kotlin.await\nimport io.github.libtmux.kotlin.send\nimport io.github.libtmux.kotlin.sessions\nimport io.github.libtmux.kotlin.withControl\nimport io.github.libtmux.kotlin.withServer\nimport java.nio.file.Path\nimport kotlin.time.Duration\nimport kotlin.time.Duration.Companion.milliseconds\nimport kotlin.time.Duration.Companion.seconds\nimport kotlinx.coroutines.flow.first\nimport kotlinx.coroutines.flow.map\nimport kotlinx.coroutines.runBlocking\nimport kotlinx.coroutines.withTimeoutOrNull\n\n/**\n * Reads a pane's output as a `Flow`, then gives up on a wait by cancelling it.\n *\n * ```\n * java -cp ... io.github.libtmux.examples.WatchWithFlowKt /tmp/libtmux-java-dev/demo/s\n * ```\n */\nfun main(args: Array<String>) {\n    val socket = Path.of(args.getOrElse(0) { \"/tmp/libtmux-java-dev/demo/s\" })\n    runBlocking { println(watchWithFlow(socket, 10.seconds)) }\n}\n\n/**\n * Collects output until the line `echo` printed arrives, then starts a channel wait that nothing\n * will signal and cancels it after a moment. Cancelling ends the coroutine at once and is not a\n * timeout; the tmux client behind the wait is stopped with it.\n *\n * @return one line for each: whether the echo arrived, and whether the wait was cancelled\n */\nsuspend fun watchWithFlow(socket: Path, deadline: Duration): String {\n    val config = ServerConfig.builder().endpoint(ServerEndpoint.socketPath(socket)).build()\n    return withServer(config) { server: Server ->\n        val session = server.sessions().first()\n        withControl(server, session) { control ->\n            // control.output(...) is a cold Flow: the subscription it opens on first collection\n            // closes when collection ends, is cancelled, or throws — nothing to close by hand. The\n            // command goes in onSubscribed: sent before collecting, its output could arrive before\n            // there was a subscription to hold it.\n            val seen = StringBuilder()\n            val echoed =\n                withTimeoutOrNull(deadline) {\n                    control.output(capacity = 32) {\n                        control.send(\"send-keys\", \"-t\", session.name, \"echo flowed\", \"Enter\")\n                    }.map { Delivery.kept(it).data }.first { chunk ->\n                        seen.append(chunk)\n                        WatchPaneOutput.printedLine(seen.toString(), \"flowed\")\n                    }\n                } != null\n\n            val cancelled =\n                withTimeoutOrNull(200.milliseconds) { server.channel(\"never-signalled\").await(30.seconds) } == null\n\n            \"echoed=$echoed\\ncancelled=$cancelled\"\n        }\n    }\n}\n"
+  },
+  "lua:examples/native_query.lua": {
+    "repository": "libtmux/libtmux-lua",
+    "revision": "777d546f87f9f5293e51f498d2addc7877b7561e",
+    "sha256": "502af1ffa1985867a5b5281eda249c1109a7e720274aac303999856b9f348b98",
+    "content": "local query = require(\"libtmux.query\")\n\nlocal schema = {\n    fields = {\n        id = { type = \"string\" },\n        active = { type = \"boolean\" },\n        current_command = { type = \"string\" },\n    },\n}\nlocal rows = {\n    { id = \"%1\", active = true, current_command = \"nvim\" },\n    { id = \"%2\", active = false, current_command = \"sh\" },\n    { id = \"%3\", active = false, current_command = \"vim\" },\n}\nlocal panes = query.select(rows, schema)\nlocal editors = panes:where({ current_command = { one_of = { \"nvim\", \"vim\" } } })\nassert(#editors == 2 and editors[1] == rows[1] and editors[2] == rows[3])\n\nlocal inactive = panes:filter(function(pane)\n    return not pane.active\nend)\nassert(#inactive == 2 and inactive[1].id == \"%2\")\nfor _, pane in ipairs(editors) do\n    print(pane.id, pane.current_command)\nend\n"
+  },
+  "lua:examples/quickstart.lua": {
+    "repository": "libtmux/libtmux-lua",
+    "revision": "777d546f87f9f5293e51f498d2addc7877b7561e",
+    "sha256": "78881ed3811b43bb096323b426028bac446c7ffd3ec32dfe0c17013f0cbb820c",
+    "content": "local adapter = require(\"libtmux.runtime.luv\")\n\nlocal function must(value, err)\n    if err ~= nil then\n        error(err, 0)\n    end\n    return value\nend\n\nlocal binary = assert(os.getenv(\"TMUX_BIN\"), \"set TMUX_BIN to an absolute tmux executable\")\nlocal socket = assert(os.getenv(\"TMUX_SOCKET\"), \"set TMUX_SOCKET to an explicit socket\")\n\nlocal result = must(adapter.run(function(runtime)\n    local server = must(runtime:connect({ binary = binary, socket_path = socket }):await())\n\n    -- docs:begin main\n    local created = must(\n        server\n            :new_session({ name = \"quickstart\", window_name = \"main\", argv = { \"/bin/sh\" } })\n            :await()\n    )\n    local logs = must(created.session:new_window({ name = \"logs\", argv = { \"/bin/cat\" } }):await())\n    local split =\n        must(logs.pane:split({ direction = \"right\", percent = 40, argv = { \"/bin/cat\" } }):await())\n\n    -- The pane signals through the same tmux binary; a bare `tmux` there may be\n    -- another build that cannot reach this server.\n    local marker = \"libtmux-lua-quickstart\"\n    local signal = (\"printf 'libtmux ready\\\\n'; '%s' wait-for -S %s\"):format(binary, marker)\n    must(created.pane:send_text(signal):await())\n    must(created.pane:send_keys({ \"Enter\" }):await())\n    must(server:command({ \"wait-for\", marker }, { timeout = 10000 }):await())\n\n    local capture = must(created.pane:capture({ history_lines = 20 }):await())\n    assert(must(capture:text()):find(\"libtmux ready\", 1, true), \"pane output was not captured\")\n    print(created.session:reference().id, logs.window:reference().id, split.pane:reference().id)\n\n    must(created.session:kill():await())\n    -- docs:end main\n    must(server:close():await())\n    return true\nend))\n\nassert(result)\n"
+  },
+  "lua:examples/snapshot.lua": {
+    "repository": "libtmux/libtmux-lua",
+    "revision": "777d546f87f9f5293e51f498d2addc7877b7561e",
+    "sha256": "4c2c130f34507c5983d266f6bd47a4af87dbc558e021a2cd2d07b7eddaf4fe56",
+    "content": "local adapter = require(\"libtmux.runtime.luv\")\n\nlocal function must(value, err)\n    if err ~= nil then\n        error(err, 0)\n    end\n    return value\nend\n\nmust(adapter.run(function(runtime)\n    local server = must(runtime\n        :connect({\n            binary = assert(os.getenv(\"TMUX_BIN\"), \"set TMUX_BIN to an absolute tmux executable\"),\n            socket_path = assert(os.getenv(\"TMUX_SOCKET\"), \"set TMUX_SOCKET to an explicit socket\"),\n        })\n        :await())\n    local snapshot = must(server:snapshot({ strict = true }):await())\n    for _, pane in ipairs(snapshot.panes) do\n        io.stdout:write(pane.id, \"\\t\", pane.window_id, \"\\n\")\n    end\n    must(server:close():await())\n    return true\nend))\n"
+  },
+  "rs:crates/libtmux/examples/scratch.rs": {
+    "repository": "libtmux/libtmux-rs",
+    "revision": "d4e08b4eaab62ef4eeedab79b47973ae9a1de310",
+    "sha256": "6c9915b602fbc477f2e8ab7b18bd0d44af59308f6f85da04bf29b50ebe01d293",
+    "content": "//! Build a throwaway session, use it, and leave nothing behind.\n//!\n//! ```console\n//! $ cargo run --example scratch\n//! ```\n\nuse std::time::Duration;\n\nuse libtmux::test::unique_name;\nuse libtmux::{NewWindowOptions, PaneWait, Server, SplitDirection, SplitOptions};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    // An example must not build sessions on whatever server the reader\n    // happens to be using, so this one gets a socket of its own. More than one\n    // libtmux runs on a developer's machine, so it goes in a directory this\n    // one owns rather than straight into the temporary directory.\n    let root = std::path::Path::new(\"/tmp/libtmux-rs-dev\");\n    std::fs::create_dir_all(root)?;\n    let socket = root.join(format!(\"{}.sock\", unique_name(\"libtmux-scratch\")));\n    let server = Server::builder().socket_path(&socket).build()?;\n\n    // The scope kills the session whether the body succeeds or fails, so a\n    // failure partway through does not leave a session behind.\n    println!(\"server on {}\", socket.display());\n\n    let output = server\n        .with_session(unique_name(\"scratch\").as_str(), async |session| {\n            println!(\"  session {} created\", session.id());\n\n            let window = session\n                .new_window(NewWindowOptions::new(\"work\").command(\"sh\"))\n                .await?;\n            println!(\"  window {} running sh\", window.id());\n\n            window\n                .split(SplitOptions::new(SplitDirection::Below).command(\"sh\"))\n                .await?;\n            println!(\"  split it: {} panes\", window.panes().await?.len());\n\n            // A window always has an active pane, but saying so with a panic\n            // would be a worse example than handling it.\n            let Some(pane) = window.active_pane().await? else {\n                return Ok(0);\n            };\n            println!(\"  typing into {}\", pane.id());\n            pane.send_line(\"printf 'hello from tmux\\\\n'\").await?;\n\n            // tmux runs the shell asynchronously, so wait for the output\n            // rather than sleeping and hoping. The outcome is checked because\n            // a wait that reached its deadline still returns successfully.\n            match pane.wait_for_text(\"hello\", Duration::from_secs(5)).await? {\n                PaneWait::Arrived => println!(\"  the pane printed it\"),\n                other => println!(\"  gave up: {other:?}\"),\n            }\n\n            // region: capture\n            let lines = pane.capture().await?;\n            for line in lines.iter().filter(|line| !line.as_bytes().is_empty()) {\n                println!(\"  | {}\", line.to_string_lossy());\n            }\n            // endregion\n\n            Ok::<_, Box<dyn std::error::Error>>(lines.len())\n        })\n        .await?;\n\n    println!(\"captured {output} lines, then the scope killed the session\");\n\n    // The lenient form is the one that answers this question. The scope killed\n    // the only session, so tmux exited with it, and the loud form reports that\n    // as the failure it is rather than as the empty listing this is asking for.\n    assert!(\n        server.sessions().await.unwrap_or_default().is_empty(),\n        \"the scope cleaned up\",\n    );\n\n    println!(\n        \"sessions left behind: {}\",\n        server.sessions().await.unwrap_or_default().len()\n    );\n\n    server.shutdown().await?;\n\n    // tmux does not unlink its socket when the server exits, so whatever named\n    // one owns removing it. Leaving it behind is invisible until /tmp fills up.\n    std::fs::remove_file(&socket)?;\n    Ok(())\n}\n"
+  },
+  "rs:crates/tmux-mcp/examples/readonly.rs": {
+    "repository": "libtmux/libtmux-rs",
+    "revision": "d4e08b4eaab62ef4eeedab79b47973ae9a1de310",
+    "sha256": "561e4fa3ab1b651b6ecc2f56a1eee2b30f1a4993565347a35f428a9a866f82bc",
+    "content": "//! Serve tmux over MCP, offering only the inspect toolset.\n//!\n//! The shipped binary reads `LIBTMUX_TOOLSETS` at startup. Building the server\n//! yourself is how you decide it in code instead, which is\n//! what you want when the surface is a property of the program rather than of\n//! how someone launched it.\n//!\n//! ```console\n//! $ cargo run --example readonly\n//! ```\n//!\n//! Then talk MCP to it on stdin and stdout.\n\nuse libtmux::Server;\nuse rmcp::ServiceExt as _;\nuse rmcp::transport::stdio;\nuse tmux_mcp::{Selection, TmuxTools};\n\n#[tokio::main]\nasync fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let tools = TmuxTools::builder(Server::new()?)\n        .selection(Selection::parse(Some(\"inspect\"), None, None)?)\n        .build();\n\n    // stdout carries the protocol, so this goes to stderr.\n    eprintln!(\"serving {} inspect tools\", tools.offered().len());\n\n    tools.serve(stdio()).await?.waiting().await?;\n    Ok(())\n}\n"
+  },
+  "ruby:examples/async_cancel.rb": {
+    "repository": "libtmux/libtmux-ruby",
+    "revision": "e3815d2b35a6c663f20769231e1d22b565f87038",
+    "sha256": "2f9a6cdc5fdf80189fe5178b51501d839d6c69da25a43304474637dff5ad0253",
+    "content": "# frozen_string_literal: true\n\nrequire \"libtmux/async\"\nrequire_relative \"support\"\n\nExample.run(\"async_cancel\") do |server|\n  server.new_session(name: \"async\", command: [\"/bin/cat\"])\n  # docs:begin main\n  Async do |parent|\n    LibTmux::Async.open(parent: parent, server: server) do |scope|\n      waiting = parent.async do\n        scope.server.run([\"wait-for\", \"-S\", \"ready\", \";\", \"wait-for\", \"held\"], timeout: 0.5)\n      rescue LibTmux::Cancelled => error\n        error\n      end\n      scope.server.wait_for(\"ready\", timeout: 0.5)\n      Example.check(scope.diagnostics.fetch(:active_process_slots) == 1, \"waiting client lost its slot\")\n      captures = scope.map(scope.server.list_panes.map(&:ref), concurrency: 2) do |ref|\n        scope.server.pane(ref).capture\n      end\n      Example.check(captures.all?(&:success?), \"sibling captures stalled\")\n      waiting.cancel\n      failure = waiting.wait\n      Example.check(failure.is_a?(LibTmux::Cancelled), \"cancellation lost\")\n      Example.check(failure.delivery == :possibly_sent, \"cancelled dispatch claimed no effects\")\n      Example.raises(Errno::ECHILD) { Process.waitpid(failure.pid, Process::WNOHANG) }\n      Example.check(scope.server.diagnostics.fetch(:admitted_requests).zero?, \"cancelled client remains admitted\")\n    end\n  end.wait\n  # docs:end main\nend\n"
+  },
+  "ruby:examples/quickstart.rb": {
+    "repository": "libtmux/libtmux-ruby",
+    "revision": "e3815d2b35a6c663f20769231e1d22b565f87038",
+    "sha256": "731d4f20bf7d8f65c95a7fbf06f42010cd793e6dfdd39539fa1f6ef28a695817",
+    "content": "# frozen_string_literal: true\n\nrequire_relative \"support\"\nrequire \"stringio\"\n\noriginal_stdout = $stdout\noutput = StringIO.new\n$stdout = output\n\nbegin\n  # docs:begin main\n  require \"libtmux\"\n\n  snapshot = LibTmux::Server.start do |server|\n    session = server.new_session(name: \"work\", window_name: \"main\", command: [\"/bin/cat\"])\n    window = session.new_window(name: \"logs\", command: [\"/bin/cat\"])\n    window.split(direction: :horizontal, size: \"40%\", command: [\"/bin/cat\"])\n\n    server.snapshot\n  end\n\n  snapshot.windows.each do |window|\n    puts \"#{window.name}: #{window.panes.map(&:id).join(', ')}\"\n  end\n  # docs:end main\n\n  # docs:begin queries\n  panes = snapshot.panes\n  active_ids = panes.where(active: true).map(&:id)\n  wide_panes = panes.select { |pane| pane.width >= 40 }\n  panes_by_window = panes.group_by { |pane| pane.window.name }\n\n  logs = snapshot.windows.one(name: \"logs\")\n  missing = snapshot.windows.one_or_nil(name: \"missing\")\n  # docs:end queries\n\n  Example.check(output.string == \"main: %0\\nlogs: %1, %2\\n\", \"unexpected window listing\")\n  Example.check(panes.size == 3 && active_ids.size == 2, \"unexpected pane selection\")\n  Example.check(wide_panes.map(&:id) == panes.where(width: {gte: 40}).map(&:id), \"block selection differs\")\n  Example.check(panes_by_window.transform_values(&:size) == {\"main\" => 1, \"logs\" => 2}, \"unexpected pane groups\")\n  Example.check(logs.panes.size == 2 && missing.nil?, \"unexpected exact lookup\")\nensure\n  $stdout = original_stdout\nend\n\nputs(ENV[\"LIBTMUX_EXAMPLE_INSTALLED\"] ? \"PASS quickstart\" : output.string)\n"
+  },
+  "scala:examples/src/main/scala/io/github/libtmux/scaladsl/examples/BlockingWorkspace.scala": {
+    "repository": "libtmux/libtmux-java",
+    "revision": "3c9ad0ee5698554b9311b3fbc63d3e33873830c6",
+    "sha256": "f5c3192be72e022670b7446e31c3a5f914e4af43c338ae1ead2ff9db0376a044",
+    "content": "package io.github.libtmux.scaladsl.examples\n\nimport io.github.libtmux.{Layout, ServerConfig, SessionSpec, SplitSpec}\n// Wildcards, not named imports: examples lives beside io.github.libtmux.scaladsl, not inside it, so\n// its generated and handwritten extension methods (isAlive, newSession, session, ...) need an\n// explicit import rather than the enclosing-package visibility a nested package would get for free.\nimport io.github.libtmux.scaladsl.*\nimport io.github.libtmux.scaladsl.query.*\nimport scala.concurrent.duration._\nimport scala.util.Using\n\n/** Builds a small workspace with the direct-style facade: a session with a\n  * split window, queried with the typed field DSL, then torn down. Every handle\n  * here is an opaque alias of the Java one — `server.newSession(...)` returns\n  * the same object `io.github.libtmux.Server.newSession` would, with a\n  * generated Scala-shaped signature.\n  */\nobject BlockingWorkspace {\n  def main(arguments: Array[String]): Unit = run(\n    ExampleRuntime.config(arguments)\n  )\n\n  def run(config: ServerConfig): Unit = Using.resource(Server.open(config)) {\n    server =>\n      require(server.isAlive(), \"example requires an existing tmux server\")\n      val name = ExampleRuntime.name(\"scala-blocking\")\n      val session = server.newSession(\n        SessionSpec.builder().named(name).running(\"/bin/sh\").build()\n      )\n      try {\n        val window = session.windows.head\n        val shell = window.panes.head\n        val second = window.split(SplitSpec.builder().running(\"cat\").build())\n        window.selectLayout(Layout.EVEN_HORIZONTAL)\n        shell.select()\n\n        shell.sendLine(\"printf 'line-%s\\\\n' submitted\")\n        assert(\n          !shell\n            .awaitText(\"line-submitted\", 5.seconds)\n            .equals(io.github.libtmux.TextOutcome.TIMED_OUT)\n        )\n        val screen = shell.capture()\n        assert(screen.exists(_.contains(\"line-submitted\")))\n\n        // The typed field DSL: Pane.command/.active on the handle's own companion, .matching as a\n        // local filter, exactlyOne for strict cardinality.\n        val panes = Vector(shell, second)\n        assert(\n          panes\n            .matching(Pane.active.is(true) || Pane.active.is(false))\n            .size == 2\n        )\n        val onlyShell = panes.matching(Pane.id.is(shell.info.id.value()))\n        assert(onlyShell.exactlyOne.equals(Right(shell)), onlyShell)\n        assert(server.session(name + \"-missing\").isEmpty)\n      } finally session.kill()\n      assert(server.isAlive())\n  }\n}\n"
+  },
+  "swift:Examples/Sources/ExampleCode/Changing.swift": {
+    "repository": "libtmux/libtmux-swift",
+    "revision": "254f8b2be7eb60cacc3ffcb3ea8e456784f582df",
+    "sha256": "b51fb2fce7c3df5571e8d596c3ca2d636cb38b2e13a8f9d6d278d1d64010f4a7",
+    "content": "// The examples in the README's \"Change what is there\" section.\n\nimport LibTmux\n\npublic func buildASessionByHand(_ server: Server) async throws -> Pane {\n    let session = try await server.newSession(named: \"work\", windowName: \"editor\")\n    _ = try await server.setOption(\"@purpose\", to: \"development\", scope: .session(session))\n    let logs = try await server.newWindow(in: session, named: \"logs\").window\n    let pane = try await server.splitWindow(logs, direction: .right)\n    try await server.run(\"tail -f /tmp/build.log\", in: pane)\n    return pane\n}\n\npublic func readBackWhatAPanePrinted(_ server: Server, _ pane: Pane) async throws -> [String] {\n    let lines = try await server.capture(pane)\n    print(lines.suffix(5).joined(separator: \"\\n\"))\n    return lines\n}\n\npublic func spendOneProcessOnAllOfIt(_ server: Server) async throws {\n    var plan = TmuxCommandList()\n    for name in [\"edit\", \"test\", \"logs\"] {\n        plan = plan.then(\"new-window\", [\"-d\", \"-n\", name])\n    }\n    _ = try await server.run(plan)\n}\n"
+  },
+  "swift:Examples/Sources/ExampleCode/Workspaces.swift": {
+    "repository": "libtmux/libtmux-swift",
+    "revision": "254f8b2be7eb60cacc3ffcb3ea8e456784f582df",
+    "sha256": "a721e1f287c7b492a598edee125a8905caf8b10a886e53d53291ffd5b99432ac",
+    "content": "// The examples in the README's `WorkspaceBuilder` section.\n\nimport Foundation\nimport LibTmux\nimport TmuxWorkspace\n\npublic func describeAWorkspaceInSwift() -> Workspace {\n    let workspace = Workspace(\n        sessionName: \"work\",\n        windows: [\n            WindowPlan(\n                windowName: \"editor\",\n                layout: \"even-horizontal\",\n                panes: [PanePlan(), PanePlan()]\n            ),\n            WindowPlan(\n                windowName: \"logs\",\n                panes: [PanePlan(shellCommands: [\"tail -f /tmp/build.log\"])]\n            ),\n        ]\n    )\n    return workspace\n}\n\npublic func buildItOnAServer(_ server: Server, _ workspace: Workspace) async throws -> Session {\n    let session = try await WorkspaceBuilder.build(workspace, on: server)\n    print(session.name, session.windowCount)\n    return session\n}\n\npublic func readAWorkspaceWrittenAsJSON(_ json: Data) throws -> Workspace {\n    try Workspace.decode(json: json)\n}\n\n// Deliberately NOT wrapped in `#if YAMLWorkspaces`. A trait defines its\n// compilation condition only inside the package that declares it, so that guard\n// in a consumer package is always false and deletes the example — loudly if a\n// test calls it, silently if nothing does. The symbol is nonetheless here,\n// because the dependency was resolved with the trait on.\npublic func readATmuxpFile(_ text: String) throws -> Workspace {\n    try Workspace.decode(yaml: text)\n}\n"
+  },
+  "ts:examples/quickstart/quickstart.ts": {
+    "repository": "libtmux/libtmux-ts",
+    "revision": "3fe1ca654b81b8cbf4a13b777a001a3298c87a6f",
+    "sha256": "4058cfefdbd2a54c69f9da93a3d57dfe2f49abd20af8256a42456fd7947c186b",
+    "content": "import { Server, TmuxCommandError, type ServerSnapshot } from \"libtmux\";\n\n/**\n * A runnable tour of the API, driven by the tests so it cannot rot.\n *\n * Every step here appears in README.md.\n */\nexport async function quickstart(server: Server): Promise<ServerSnapshot> {\n  // Nothing is read until you ask. `snapshot()` is the only step that talks to\n  // tmux; everything reachable from it resolves locally.\n  const session = await server.newSession({ name: \"quickstart\" });\n  const editor = await session.newWindow({ name: \"editor\" });\n  await editor.split();\n\n  const snapshot = await server.snapshot();\n\n  // Declarative filtering, serializable and stable on the wire.\n  const found = snapshot.windows.where({ name: \"editor\" }).one();\n\n  // Relations are plain properties: no await, no tmux command.\n  const paneCount = found.panes.length;\n  if (paneCount !== 2) throw new Error(`expected two panes, saw ${String(paneCount)}`);\n\n  // A criterion is spelled like the handle accessor it filters.\n  if (snapshot.panes.count({ currentCommand: { contains: \"\" } }) === 0) {\n    throw new Error(\"expected panes to report a current command\");\n  }\n  const first = found.panes.at(0);\n  if (first === undefined) throw new Error(\"expected a pane\");\n  await first.sendKeys(\"echo hello-from-libtmux\", { literal: true });\n\n  // Failures carry their parts rather than a formatted sentence.\n  try {\n    await server.setOption(\"not-a-real-option\", \"1\");\n  } catch (error) {\n    if (!(error instanceof TmuxCommandError)) throw error;\n    if (error.args[0] !== \"set-option\") throw error;\n  }\n\n  return snapshot;\n}\n"
+  },
+  "ts:examples/workspace/workspace.ts": {
+    "repository": "libtmux/libtmux-ts",
+    "revision": "3fe1ca654b81b8cbf4a13b777a001a3298c87a6f",
+    "sha256": "35ffadc734aad94422f0e7c939bd448db97e13130d1c79047ba9c343a0672cf2",
+    "content": "import type { Server } from \"libtmux/server\";\nimport type { Session } from \"libtmux/session\";\nimport { applyWorkspace } from \"@libtmux/workspace\";\nimport type { WorkspaceInput } from \"@libtmux/workspace/config\";\n\n/**\n * Build the shape most people reach for tmux to get: one session, a window\n * per concern, each pane already running the thing it is there for.\n *\n * `server.batch` plans several windows and resolves them from one final\n * snapshot. `buildWorkspace`, below, delegates declared topology to the\n * workspace package instead of maintaining another reconciler here.\n */\nexport async function buildSimpleWorkspace(server: Server): Promise<Session> {\n  const built = await server.newSession({\n    name: \"work\",\n    shellCommand: \"sleep 30\",\n    windowName: \"editor\",\n  });\n\n  const [logs, shell] = await server.batch([\n    built.plan.newWindow({ name: \"logs\", shellCommand: \"tail -f /dev/null\" }),\n    built.plan.newWindow({ name: \"shell\" }),\n  ]);\n\n  await logs.selectLayout(\"even-horizontal\");\n  void shell.name; // \"shell\"\n\n  return built;\n}\n\nexport const DEVELOPMENT_WORKSPACE = {\n  session_name: \"workspace-example\",\n  windows: [\n    { panes: [\"sleep 30\", \"sleep 30\"], window_name: \"editor\" },\n    { panes: [\"sleep 30\"], window_name: \"server\" },\n    { window_name: \"logs\" },\n  ],\n} satisfies WorkspaceInput;\n\n/** Apply the package's declarative workspace to a server. */\nexport function buildWorkspace(server: Server): Promise<Session> {\n  return applyWorkspace(server, DEVELOPMENT_WORKSPACE);\n}\n\n/**\n * Tear a workspace down without caring whether it is there.\n *\n * Killing a session that has already gone is not a failure worth propagating,\n * which is the one case worth handling separately from every other tmux error.\n */\nexport async function removeWorkspace(server: Server, name: string): Promise<boolean> {\n  const found = (await server.snapshot()).sessions.first({ name });\n  if (found === undefined) return false;\n  await found.kill();\n  return true;\n}\n"
+  }
 }
diff --git a/site/src/data/mentions.json b/site/src/data/mentions.json
index 5db9164f..63a3a82f 100644
--- a/site/src/data/mentions.json
+++ b/site/src/data/mentions.json
@@ -7,13 +7,6 @@
    "title": "Control mode vs one-shot",
    "section": "concepts"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::CommandBatch::request",
-   "page": "/lua/latest/guides/options/",
-   "title": "tmux option and hook reference",
-   "section": "guides"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::CommandOperation::wait_until",
@@ -21,27 +14,6 @@
    "title": "Waiting and retrying",
    "section": "topics"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::CommandRuntime::close",
-   "page": "/lua/latest/guides/control/",
-   "title": "Observing a session",
-   "section": "guides"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::CommandRuntime::close",
-   "page": "/ruby/latest/guides/core/",
-   "title": "libtmux",
-   "section": "guides"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::CommandRuntime::close",
-   "page": "/ruby/latest/guides/ownership-errors/",
-   "title": "Ownership and errors",
-   "section": "guides"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::Connection",
@@ -56,13 +28,6 @@
    "title": "Attach and send keys",
    "section": "examples"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Connection::shutdown",
-   "page": "/topics/context-managers/",
-   "title": "Context managers",
-   "section": "topics"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::DeliveryStatus",
@@ -101,8 +66,8 @@
   {
    "port": "cxx",
    "symbol": "libtmux::detail::Row::server",
-   "page": "/cxx/latest/workspace/internals/examples/",
-   "title": "C++ workspace builder examples",
+   "page": "/cxx/latest/workspace/cli/shell/",
+   "title": "Evaluate in a workspace",
    "section": "ports"
   },
   {
@@ -112,20 +77,6 @@
    "title": "Filtering and querying, in practice",
    "section": "guides"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::FailureKind::unsupported",
-   "page": "/lua/latest/guides/buffers/",
-   "title": "Read and paste named buffers",
-   "section": "guides"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::FailureKind::unsupported",
-   "page": "/lua/latest/guides/panes/",
-   "title": "Pane operations",
-   "section": "guides"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::FilterExpr",
@@ -196,13 +147,6 @@
    "title": "C++ MCP API",
    "section": "ports"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::mcp::ToolSchema::input",
-   "page": "/cxx/latest/workspace/reference/output/",
-   "title": "JSON, NDJSON, and semantic color",
-   "section": "ports"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::mcp::Toolset::execute",
@@ -231,20 +175,6 @@
    "title": "C++ MCP topics",
    "section": "ports"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::OptionEntry::inherited",
-   "page": "/lua/latest/guides/environment/",
-   "title": "Persistent environment",
-   "section": "guides"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::OptionEntry::inherited",
-   "page": "/lua/latest/guides/settings/",
-   "title": "Options and hooks",
-   "section": "guides"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::Pane",
@@ -256,14 +186,7 @@
    "port": "cxx",
    "symbol": "libtmux::Pane",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
-   "section": "topics"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Pane",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -280,20 +203,6 @@
    "title": "Traversal",
    "section": "topics"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Pane::capture",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Pane::capture",
-   "page": "/guides/capturing-output/",
-   "title": "Capturing output",
-   "section": "guides"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::Pane::expand",
@@ -317,10 +226,10 @@
   },
   {
    "port": "cxx",
-   "symbol": "libtmux::Pane::respawn",
-   "page": "/lua/latest/guides/panes/",
-   "title": "Pane operations",
-   "section": "guides"
+   "symbol": "libtmux::Pane::send_key",
+   "page": "/topics/pane-interaction/",
+   "title": "Pane interaction",
+   "section": "topics"
   },
   {
    "port": "cxx",
@@ -364,13 +273,6 @@
    "title": "C++ workspace internals",
    "section": "ports"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server",
-   "page": "/cxx/latest/workspace/internals/examples/",
-   "title": "C++ workspace builder examples",
-   "section": "ports"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::Server",
@@ -385,27 +287,6 @@
    "title": "C++ workspace builder behavior",
    "section": "ports"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server",
-   "page": "/guides/attaching-to-tmux/",
-   "title": "Attaching to tmux",
-   "section": "guides"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server",
-   "page": "/topics/architecture/",
-   "title": "Architecture",
-   "section": "topics"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server",
-   "page": "/topics/options-and-hooks/",
-   "title": "Options and hooks",
-   "section": "topics"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::Server::at_default",
@@ -462,20 +343,6 @@
    "title": "Socket and servers",
    "section": "topics"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server::remove_environment",
-   "page": "/lua/latest/guides/environment/",
-   "title": "Persistent environment",
-   "section": "guides"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server::remove_environment",
-   "page": "/topics/environment/",
-   "title": "Environment",
-   "section": "topics"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::Server::sessions",
@@ -490,27 +357,6 @@
    "title": "Waiting and retrying",
    "section": "topics"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server::unset_environment",
-   "page": "/lua/latest/guides/environment/",
-   "title": "Persistent environment",
-   "section": "guides"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server::unset_environment",
-   "page": "/topics/environment/",
-   "title": "Environment",
-   "section": "topics"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Server::wait_for",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::Server::wait_for",
@@ -536,21 +382,7 @@
    "port": "cxx",
    "symbol": "libtmux::Session",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
-   "section": "topics"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Session",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
-   "section": "topics"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Session",
-   "page": "/topics/options-and-hooks/",
-   "title": "Options and hooks",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -581,13 +413,6 @@
    "title": "Traversal",
    "section": "topics"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Session::set_hook",
-   "page": "/lua/latest/guides/settings/",
-   "title": "Options and hooks",
-   "section": "guides"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::Session::set_hook",
@@ -602,13 +427,6 @@
    "title": "Traversal",
    "section": "topics"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::SplitOptions::full_size",
-   "page": "/lua/latest/guides/creation/",
-   "title": "Create sessions, windows and panes",
-   "section": "guides"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::StringFieldHandle::starts_with",
@@ -616,18 +434,11 @@
    "title": "Filtering and queries",
    "section": "concepts"
   },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::test::ScopedTmuxServer",
-   "page": "/cxx/latest/workspace/internals/examples/",
-   "title": "C++ workspace builder examples",
-   "section": "ports"
-  },
   {
    "port": "cxx",
    "symbol": "libtmux::test::ScopedTmuxServer",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -648,14 +459,7 @@
    "port": "cxx",
    "symbol": "libtmux::Window",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
-   "section": "topics"
-  },
-  {
-   "port": "cxx",
-   "symbol": "libtmux::Window",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -742,6 +546,13 @@
    "title": "C++ workspace builder API",
    "section": "ports"
   },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::BuildError::window_index",
+   "page": "/cxx/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
+   "section": "ports"
+  },
   {
    "port": "cxx",
    "symbol": "libtmux::workspace::Command",
@@ -756,6 +567,34 @@
    "title": "C++ workspace builder API",
    "section": "ports"
   },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::Command::enter",
+   "page": "/cxx/latest/workspace/configuration/commands/",
+   "title": "Workspace commands",
+   "section": "ports"
+  },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::Command::enter",
+   "page": "/cxx/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
+  },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::Command::suppress_history",
+   "page": "/cxx/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
+  },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::Command::suppress_history",
+   "page": "/cxx/latest/workspace/configuration/session/",
+   "title": "Session configuration",
+   "section": "ports"
+  },
   {
    "port": "cxx",
    "symbol": "libtmux::workspace::Pane",
@@ -822,8 +661,8 @@
   {
    "port": "cxx",
    "symbol": "libtmux::workspace::Window::options_after",
-   "page": "/cxx/latest/workspace/cli/freeze/",
-   "title": "tmuxp freeze",
+   "page": "/cxx/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
    "section": "ports"
   },
   {
@@ -835,9 +674,16 @@
   },
   {
    "port": "cxx",
-   "symbol": "libtmux::workspace::Window::options_after",
-   "page": "/cxx/latest/workspace/reference/compatibility/",
-   "title": "tmuxp compatibility and port status",
+   "symbol": "libtmux::workspace::Window::panes",
+   "page": "/cxx/latest/workspace/cli/import-tmuxinator/",
+   "title": "Import from tmuxinator",
+   "section": "ports"
+  },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::Window::panes",
+   "page": "/cxx/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
    "section": "ports"
   },
   {
@@ -854,11 +700,32 @@
    "title": "C++ workspace builder API",
    "section": "ports"
   },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::Workspace::global_options",
+   "page": "/cxx/latest/workspace/configuration/session/",
+   "title": "Session configuration",
+   "section": "ports"
+  },
   {
    "port": "cxx",
    "symbol": "libtmux::workspace::Workspace::session_name",
-   "page": "/cxx/latest/workspace/reference/output/",
-   "title": "JSON, NDJSON, and semantic color",
+   "page": "/cxx/latest/workspace/configuration/session/",
+   "title": "Session configuration",
+   "section": "ports"
+  },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::Workspace::windows",
+   "page": "/cxx/latest/workspace/configuration/session/",
+   "title": "Session configuration",
+   "section": "ports"
+  },
+  {
+   "port": "cxx",
+   "symbol": "libtmux::workspace::Workspace::windows",
+   "page": "/cxx/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
    "section": "ports"
   },
   {
@@ -910,18 +777,25 @@
    "title": ".NET MCP API",
    "section": "ports"
   },
+  {
+   "port": "dotnet",
+   "symbol": "LibTmux.NewSessionRequest.ReplaceExisting",
+   "page": "/guides/attaching-to-tmux/",
+   "title": "Attaching to tmux",
+   "section": "guides"
+  },
   {
    "port": "dotnet",
    "symbol": "LibTmux.OwnedSessionScope",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
    "port": "dotnet",
    "symbol": "LibTmux.OwnedWindowScope",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -931,13 +805,6 @@
    "title": "Architecture",
    "section": "topics"
   },
-  {
-   "port": "dotnet",
-   "symbol": "LibTmux.Pane.CaptureAsync",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
   {
    "port": "dotnet",
    "symbol": "LibTmux.Pane.CaptureAsync",
@@ -996,7 +863,7 @@
   },
   {
    "port": "dotnet",
-   "symbol": "LibTmux.SendKeysRequest",
+   "symbol": "LibTmux.SendKeysRequest.Literal",
    "page": "/topics/pane-interaction/",
    "title": "Pane interaction",
    "section": "topics"
@@ -1008,13 +875,6 @@
    "title": ".NET workspace internals",
    "section": "ports"
   },
-  {
-   "port": "dotnet",
-   "symbol": "LibTmux.Server",
-   "page": "/dotnet/latest/workspace/internals/examples/",
-   "title": ".NET workspace builder examples",
-   "section": "ports"
-  },
   {
    "port": "dotnet",
    "symbol": "LibTmux.Server",
@@ -1031,18 +891,25 @@
   },
   {
    "port": "dotnet",
-   "symbol": "LibTmux.Server.EnterControlModeAsync",
-   "page": "/concepts/transports/",
-   "title": "Control mode vs one-shot",
-   "section": "concepts"
+   "symbol": "LibTmux.Server.CreateOwnedAsync",
+   "page": "/dotnet/latest/workspace/internals/guides/",
+   "title": "Use the .NET workspace builder",
+   "section": "ports"
   },
   {
    "port": "dotnet",
-   "symbol": "LibTmux.Server.FromEnvironment",
+   "symbol": "LibTmux.Server.CreateSessionAsync",
    "page": "/guides/attaching-to-tmux/",
    "title": "Attaching to tmux",
    "section": "guides"
   },
+  {
+   "port": "dotnet",
+   "symbol": "LibTmux.Server.EnterControlModeAsync",
+   "page": "/concepts/transports/",
+   "title": "Control mode vs one-shot",
+   "section": "concepts"
+  },
   {
    "port": "dotnet",
    "symbol": "LibTmux.Server.FromEnvironment",
@@ -1085,6 +952,13 @@
    "title": "Waiting and retrying",
    "section": "topics"
   },
+  {
+   "port": "dotnet",
+   "symbol": "LibTmux.ServerConnectionOptions",
+   "page": "/dotnet/latest/workspace/internals/guides/",
+   "title": "Use the .NET workspace builder",
+   "section": "ports"
+  },
   {
    "port": "dotnet",
    "symbol": "LibTmux.ServerConnectionOptions",
@@ -1095,8 +969,15 @@
   {
    "port": "dotnet",
    "symbol": "LibTmux.Session",
-   "page": "/topics/traversal/",
-   "title": "Traversal",
+   "page": "/topics/context-managers/",
+   "title": "Ownership and cleanup",
+   "section": "topics"
+  },
+  {
+   "port": "dotnet",
+   "symbol": "LibTmux.Session",
+   "page": "/topics/traversal/",
+   "title": "Traversal",
    "section": "topics"
   },
   {
@@ -1131,14 +1012,14 @@
    "port": "dotnet",
    "symbol": "LibTmux.Testing.TemporaryHierarchyScope",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
    "port": "dotnet",
    "symbol": "LibTmux.Testing.TmuxTestFactory.CreateHierarchyAsync",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -1284,9 +1165,9 @@
   {
    "port": "dotnet",
    "symbol": "LibTmux.TmuxWait.UntilAsync",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
+   "page": "/guides/sending-keys/",
+   "title": "Sending keys",
+   "section": "guides"
   },
   {
    "port": "dotnet",
@@ -1323,6 +1204,13 @@
    "title": "Waiting and retrying",
    "section": "topics"
   },
+  {
+   "port": "dotnet",
+   "symbol": "LibTmux.Window",
+   "page": "/topics/context-managers/",
+   "title": "Ownership and cleanup",
+   "section": "topics"
+  },
   {
    "port": "dotnet",
    "symbol": "LibTmux.Window",
@@ -1449,6 +1337,20 @@
    "title": ".NET workspace internals",
    "section": "ports"
   },
+  {
+   "port": "dotnet",
+   "symbol": "LibTmux.Workspace.WorkspaceBuilder.BuildAsync",
+   "page": "/dotnet/latest/workspace/internals/examples/",
+   "title": ".NET workspace builder examples",
+   "section": "ports"
+  },
+  {
+   "port": "dotnet",
+   "symbol": "LibTmux.Workspace.WorkspaceBuilder.BuildAsync",
+   "page": "/dotnet/latest/workspace/internals/guides/",
+   "title": "Use the .NET workspace builder",
+   "section": "ports"
+  },
   {
    "port": "dotnet",
    "symbol": "LibTmux.Workspace.WorkspaceBuilder.BuildAsync",
@@ -1550,22 +1452,22 @@
   {
    "port": "dotnet",
    "symbol": "LibTmux.Workspace.WorkspaceResult",
-   "page": "/dotnet/latest/workspace/reference/",
-   "title": ".NET workspace builder API",
+   "page": "/dotnet/latest/workspace/internals/guides/",
+   "title": "Use the .NET workspace builder",
    "section": "ports"
   },
   {
    "port": "dotnet",
-   "symbol": "LibTmux.Workspace.WorkspaceResult.Unsupported",
-   "page": "/dotnet/latest/workspace/configuration/layouts/",
-   "title": "Workspace layouts and focus",
+   "symbol": "LibTmux.Workspace.WorkspaceResult",
+   "page": "/dotnet/latest/workspace/reference/",
+   "title": ".NET workspace builder API",
    "section": "ports"
   },
   {
    "port": "dotnet",
    "symbol": "LibTmux.Workspace.WorkspaceResult.Unsupported",
-   "page": "/dotnet/latest/workspace/internals/examples/",
-   "title": ".NET workspace builder examples",
+   "page": "/dotnet/latest/workspace/internals/guides/",
+   "title": "Use the .NET workspace builder",
    "section": "ports"
   },
   {
@@ -1617,6 +1519,13 @@
    "title": "Go MCP API",
    "section": "ports"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.CaptureBoundary",
+   "page": "/topics/pane-interaction/",
+   "title": "Pane interaction",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.CommandError.Is",
@@ -1628,7 +1537,7 @@
    "port": "go",
    "symbol": "tmux.ControlClient",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -1638,6 +1547,20 @@
    "title": "Socket and servers",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.ErrNoServer",
+   "page": "/topics/errors-and-exceptions/",
+   "title": "Errors and exceptions",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.ErrNotFound",
+   "page": "/topics/errors-and-exceptions/",
+   "title": "Errors and exceptions",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.FromEnvError",
@@ -1663,68 +1586,75 @@
    "port": "go",
    "symbol": "tmux.NotificationStream",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.DeadSignal",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
+   "symbol": "tmux.OptionValue",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.DeadTime",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
+   "symbol": "tmux.OptionValue.Get",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.Hooks",
-   "page": "/topics/options-and-hooks/",
-   "title": "Options and hooks",
+   "symbol": "tmux.Pane",
+   "page": "/topics/context-managers/",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.Options",
-   "page": "/topics/options-and-hooks/",
-   "title": "Options and hooks",
+   "symbol": "tmux.Pane.Capture",
+   "page": "/topics/pane-interaction/",
+   "title": "Pane interaction",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.SetHook",
-   "page": "/topics/options-and-hooks/",
-   "title": "Options and hooks",
+   "symbol": "tmux.Pane.DeadSignal",
+   "page": "/topics/format-tokens/",
+   "title": "Format-token fields",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.SetHooks",
-   "page": "/topics/options-and-hooks/",
-   "title": "Options and hooks",
+   "symbol": "tmux.Pane.DeadTime",
+   "page": "/topics/format-tokens/",
+   "title": "Format-token fields",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.SetOption",
-   "page": "/topics/options-and-hooks/",
-   "title": "Options and hooks",
+   "symbol": "tmux.Pane.ID",
+   "page": "/topics/traversal/",
+   "title": "Traversal",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.Pane.OpenObservation",
+   "page": "/topics/pane-interaction/",
+   "title": "Pane interaction",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.UnsetHook",
+   "symbol": "tmux.Pane.Options",
    "page": "/topics/options-and-hooks/",
    "title": "Options and hooks",
    "section": "topics"
   },
   {
    "port": "go",
-   "symbol": "tmux.Pane.UnsetOption",
+   "symbol": "tmux.Pane.RawOption",
    "page": "/topics/options-and-hooks/",
    "title": "Options and hooks",
    "section": "topics"
@@ -1736,6 +1666,20 @@
    "title": "Traversal",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.PaneFilter",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.PaneFilter.Predicate",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
+  },
   {
    "port": "go",
    "symbol": "tmux.PaneFromEnv",
@@ -1754,7 +1698,7 @@
    "port": "go",
    "symbol": "tmux.PaneObservation",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -1792,6 +1736,13 @@
    "title": "Socket and servers",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Server.GlobalSessionScope",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.Server.IsAlive",
@@ -1806,6 +1757,20 @@
    "title": "Socket and servers",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Server.SearchPanes",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.Server.SearchPanes",
+   "page": "/concepts/server-session-window-pane/",
+   "title": "Server, session, window, pane",
+   "section": "concepts"
+  },
   {
    "port": "go",
    "symbol": "tmux.Server.Sessions",
@@ -1827,6 +1792,13 @@
    "title": "Environment",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Server.Snapshot",
+   "page": "/concepts/server-session-window-pane/",
+   "title": "Server, session, window, pane",
+   "section": "concepts"
+  },
   {
    "port": "go",
    "symbol": "tmux.Server.UnsetEnvironment",
@@ -1841,6 +1813,27 @@
    "title": "Pane interaction",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.ServerOptions.SocketName",
+   "page": "/topics/socket-and-servers/",
+   "title": "Socket and servers",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.ServerOptions.SocketPath",
+   "page": "/topics/socket-and-servers/",
+   "title": "Socket and servers",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.Session",
+   "page": "/topics/context-managers/",
+   "title": "Ownership and cleanup",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.Session.ActiveWindow",
@@ -1848,6 +1841,13 @@
    "title": "Traversal",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Session.Hooks",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.Session.OpenControl",
@@ -1858,9 +1858,9 @@
   {
    "port": "go",
    "symbol": "tmux.Session.OpenNotifications",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
+   "page": "/concepts/transports/",
+   "title": "Control mode vs one-shot",
+   "section": "concepts"
   },
   {
    "port": "go",
@@ -1869,6 +1869,20 @@
    "title": "Traversal",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Session.Run",
+   "page": "/topics/pane-interaction/",
+   "title": "Pane interaction",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.Session.SearchWindows",
+   "page": "/concepts/server-session-window-pane/",
+   "title": "Server, session, window, pane",
+   "section": "concepts"
+  },
   {
    "port": "go",
    "symbol": "tmux.Session.SearchWindows",
@@ -1876,6 +1890,34 @@
    "title": "Use the Go workspace builder",
    "section": "ports"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Session.SearchWindows",
+   "page": "/topics/waiting-and-retry/",
+   "title": "Waiting and retrying",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.Session.SetHook",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.Session.SetHooks",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.Session.UnsetHook",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.Session.Windows",
@@ -1883,6 +1925,13 @@
    "title": "Traversal",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Session.Windows",
+   "page": "/topics/waiting-and-retry/",
+   "title": "Waiting and retrying",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.SessionFromEnv",
@@ -1890,6 +1939,20 @@
    "title": "Environment",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.TmuxFilter",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.WaitForRequest",
+   "page": "/topics/pane-interaction/",
+   "title": "Pane interaction",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.WaitForRequest.Mode",
@@ -1897,6 +1960,13 @@
    "title": "Waiting and retrying",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Window",
+   "page": "/topics/context-managers/",
+   "title": "Ownership and cleanup",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.Window.ActivePane",
@@ -1904,6 +1974,13 @@
    "title": "Traversal",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Window.Options",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.Window.Panes",
@@ -1918,6 +1995,20 @@
    "title": "Traversal",
    "section": "topics"
   },
+  {
+   "port": "go",
+   "symbol": "tmux.Window.SetOption",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
+   "section": "topics"
+  },
+  {
+   "port": "go",
+   "symbol": "tmux.Window.UnsetOption",
+   "page": "/topics/options-and-hooks/",
+   "title": "Options and hooks",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmux.WindowFromEnv",
@@ -1948,7 +2039,7 @@
   },
   {
    "port": "go",
-   "symbol": "tmuxq.Where",
+   "symbol": "tmuxq.Matching",
    "page": "/concepts/queries/",
    "title": "Filtering and queries",
    "section": "concepts"
@@ -1960,6 +2051,13 @@
    "title": "Filtering and querying, in practice",
    "section": "guides"
   },
+  {
+   "port": "go",
+   "symbol": "tmuxtest.Main",
+   "page": "/guides/testing-with-libtmux/",
+   "title": "Testing with libtmux",
+   "section": "guides"
+  },
   {
    "port": "go",
    "symbol": "tmuxtest.NewServer",
@@ -1967,6 +2065,13 @@
    "title": "Testing with libtmux",
    "section": "guides"
   },
+  {
+   "port": "go",
+   "symbol": "tmuxtest.NewServer",
+   "page": "/topics/context-managers/",
+   "title": "Ownership and cleanup",
+   "section": "topics"
+  },
   {
    "port": "go",
    "symbol": "tmuxtest.WaitFor",
@@ -1981,13 +2086,6 @@
    "title": "Sending keys",
    "section": "guides"
   },
-  {
-   "port": "go",
-   "symbol": "tmuxtest.WaitForText",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
   {
    "port": "go",
    "symbol": "workspace.Bool",
@@ -2170,13 +2268,6 @@
    "title": "Go workspace builder API",
    "section": "ports"
   },
-  {
-   "port": "go",
-   "symbol": "workspace.Workspace.MissingDirectories",
-   "page": "/go/latest/workspace/configuration/directories/",
-   "title": "Workspace files and directories",
-   "section": "ports"
-  },
   {
    "port": "go",
    "symbol": "workspace.Workspace.MissingDirectories",
@@ -2198,13 +2289,6 @@
    "title": "Control mode vs one-shot",
    "section": "concepts"
   },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Buffers.Buffers.load",
-   "page": "/java/latest/workspace/cli/freeze/",
-   "title": "tmuxp freeze",
-   "section": "ports"
-  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.Channel.Channel.drain",
@@ -2219,13 +2303,6 @@
    "title": "Control mode vs one-shot",
    "section": "concepts"
   },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.control.ControlClient.ControlClient",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.control.ControlClient.ControlClient.attach",
@@ -2247,13 +2324,6 @@
    "title": "Control mode vs one-shot",
    "section": "concepts"
   },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.control.ControlWriter.ControlWriter.exchange",
-   "page": "/ruby/latest/guides/async/",
-   "title": "libtmux-async",
-   "section": "guides"
-  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.Hooks.Hooks",
@@ -2299,71 +2369,15 @@
   {
    "port": "java",
    "symbol": "io.github.libtmux.Pane_.Pane_",
-   "page": "/topics/architecture/",
-   "title": "Architecture",
-   "section": "topics"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.height",
-   "page": "/lua/latest/guides/creation/",
-   "title": "Create sessions, windows and panes",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.height",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.height",
-   "page": "/lua/latest/guides/topology/",
-   "title": "Topology operations",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.height",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
-   "section": "topics"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.index",
    "page": "/concepts/queries/",
    "title": "Filtering and queries",
    "section": "concepts"
   },
   {
    "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.width",
-   "page": "/lua/latest/guides/creation/",
-   "title": "Create sessions, windows and panes",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.width",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.width",
-   "page": "/lua/latest/guides/topology/",
-   "title": "Topology operations",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane_.Pane_.width",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
+   "symbol": "io.github.libtmux.Pane_.Pane_",
+   "page": "/topics/architecture/",
+   "title": "Architecture",
    "section": "topics"
   },
   {
@@ -2380,20 +2394,6 @@
    "title": "Capturing output",
    "section": "guides"
   },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane.Pane.created",
-   "page": "/lua/latest/guides/creation/",
-   "title": "Create sessions, windows and panes",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane.Pane.created",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.Pane.Pane.equals",
@@ -2422,20 +2422,6 @@
    "title": "Options and hooks",
    "section": "topics"
   },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane.Pane.pid",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Pane.Pane.pid",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
-   "section": "topics"
-  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.Pane.Pane.send",
@@ -2459,11 +2445,32 @@
   },
   {
    "port": "java",
-   "symbol": "io.github.libtmux.PaneCommand.PaneCommand.status",
-   "page": "/java/latest/workspace/reference/output/",
-   "title": "JSON, NDJSON, and semantic color",
+   "symbol": "io.github.libtmux.PaneStart.PaneStart.shell",
+   "page": "/java/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
+  },
+  {
+   "port": "java",
+   "symbol": "io.github.libtmux.PaneStart.PaneStart.shell",
+   "page": "/java/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
+   "section": "ports"
+  },
+  {
+   "port": "java",
+   "symbol": "io.github.libtmux.PaneStart.PaneStart.shell",
+   "page": "/java/latest/workspace/reference/compatibility/",
+   "title": "Runtime and configuration support",
    "section": "ports"
   },
+  {
+   "port": "java",
+   "symbol": "io.github.libtmux.query.Fields.Fields.TextField.startsWith",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
+  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.query.Selections.Selections.exactlyOne",
@@ -2506,13 +2513,6 @@
    "title": "Java workspace internals",
    "section": "ports"
   },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Server.Server",
-   "page": "/java/latest/workspace/internals/examples/",
-   "title": "Java workspace builder examples",
-   "section": "ports"
-  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.Server.Server",
@@ -2531,7 +2531,7 @@
    "port": "java",
    "symbol": "io.github.libtmux.Server.Server",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -2557,24 +2557,17 @@
   },
   {
    "port": "java",
-   "symbol": "io.github.libtmux.Server.Server.open",
-   "page": "/ruby/latest/guides/core/",
-   "title": "libtmux",
-   "section": "guides"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Server.Server.open",
-   "page": "/ruby/latest/guides/execution-modes/",
-   "title": "Execution modes",
-   "section": "guides"
+   "symbol": "io.github.libtmux.Server.Server.killServer",
+   "page": "/java/latest/workspace/internals/examples/",
+   "title": "Java workspace builder examples",
+   "section": "ports"
   },
   {
    "port": "java",
-   "symbol": "io.github.libtmux.Server.Server.open",
-   "page": "/ruby/latest/guides/overview/",
-   "title": "libtmux for Ruby",
-   "section": "guides"
+   "symbol": "io.github.libtmux.Server.Server.killServer",
+   "page": "/topics/socket-and-servers/",
+   "title": "Socket and servers",
+   "section": "topics"
   },
   {
    "port": "java",
@@ -2607,23 +2600,16 @@
   {
    "port": "java",
    "symbol": "io.github.libtmux.Session_.Session_",
-   "page": "/topics/architecture/",
-   "title": "Architecture",
-   "section": "topics"
-  },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.Session_.Session_.name",
    "page": "/concepts/queries/",
    "title": "Filtering and queries",
    "section": "concepts"
   },
   {
    "port": "java",
-   "symbol": "io.github.libtmux.Session.Session",
-   "page": "/java/latest/workspace/internals/examples/",
-   "title": "Java workspace builder examples",
-   "section": "ports"
+   "symbol": "io.github.libtmux.Session_.Session_",
+   "page": "/topics/architecture/",
+   "title": "Architecture",
+   "section": "topics"
   },
   {
    "port": "java",
@@ -2662,10 +2648,24 @@
   },
   {
    "port": "java",
-   "symbol": "io.github.libtmux.TmuxEnvironment.TmuxEnvironment.current",
-   "page": "/lua/latest/guides/options/",
-   "title": "tmux option and hook reference",
-   "section": "guides"
+   "symbol": "io.github.libtmux.SessionSpec.SessionSpec.Builder.environment",
+   "page": "/topics/environment/",
+   "title": "Environment",
+   "section": "topics"
+  },
+  {
+   "port": "java",
+   "symbol": "io.github.libtmux.SplitSpec.SplitSpec.Builder.environment",
+   "page": "/topics/environment/",
+   "title": "Environment",
+   "section": "topics"
+  },
+  {
+   "port": "java",
+   "symbol": "io.github.libtmux.TmuxEnvironment.TmuxEnvironment",
+   "page": "/topics/environment/",
+   "title": "Environment",
+   "section": "topics"
   },
   {
    "port": "java",
@@ -2695,6 +2695,13 @@
    "title": "Waiting and retrying",
    "section": "topics"
   },
+  {
+   "port": "java",
+   "symbol": "io.github.libtmux.Window_.Window_",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
+  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.Window_.Window_",
@@ -2730,6 +2737,13 @@
    "title": "Traversal",
    "section": "topics"
   },
+  {
+   "port": "java",
+   "symbol": "io.github.libtmux.WindowSpec.WindowSpec.Builder.environment",
+   "page": "/topics/environment/",
+   "title": "Environment",
+   "section": "topics"
+  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.workspace.PaneSpec.PaneSpec",
@@ -2751,13 +2765,6 @@
    "title": "Build a workspace from a file",
    "section": "examples"
   },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.workspace.Workspace.Workspace",
-   "page": "/java/latest/workspace/internals/examples/",
-   "title": "Java workspace builder examples",
-   "section": "ports"
-  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.workspace.Workspace.Workspace",
@@ -2779,13 +2786,6 @@
    "title": "Java workspace internals",
    "section": "ports"
   },
-  {
-   "port": "java",
-   "symbol": "io.github.libtmux.workspace.WorkspaceBuilder.WorkspaceBuilder",
-   "page": "/java/latest/workspace/internals/examples/",
-   "title": "Java workspace builder examples",
-   "section": "ports"
-  },
   {
    "port": "java",
    "symbol": "io.github.libtmux.workspace.WorkspaceBuilder.WorkspaceBuilder",
@@ -3073,13 +3073,6 @@
    "title": "Query captured data",
    "section": "guides"
   },
-  {
-   "port": "lua",
-   "symbol": "libtmux.FieldCriteria.eq",
-   "page": "/concepts/queries/",
-   "title": "Filtering and queries",
-   "section": "concepts"
-  },
   {
    "port": "lua",
    "symbol": "libtmux.FieldCriteria.eq",
@@ -3087,13 +3080,6 @@
    "title": "Query captured data",
    "section": "guides"
   },
-  {
-   "port": "lua",
-   "symbol": "libtmux.FieldCriteria.gt",
-   "page": "/concepts/queries/",
-   "title": "Filtering and queries",
-   "section": "concepts"
-  },
   {
    "port": "lua",
    "symbol": "libtmux.FieldCriteria.gt",
@@ -3192,13 +3178,6 @@
    "title": "tmux option and hook reference",
    "section": "guides"
   },
-  {
-   "port": "lua",
-   "symbol": "libtmux.LiveQueryPlan.exact",
-   "page": "/concepts/queries/",
-   "title": "Filtering and queries",
-   "section": "concepts"
-  },
   {
    "port": "lua",
    "symbol": "libtmux.LiveQueryResult.plan",
@@ -4109,13 +4088,6 @@
    "title": "Attaching to tmux",
    "section": "guides"
   },
-  {
-   "port": "py",
-   "symbol": "libtmux._internal.env.TMUX",
-   "page": "/guides/testing-with-libtmux/",
-   "title": "Testing with libtmux",
-   "section": "guides"
-  },
   {
    "port": "py",
    "symbol": "libtmux._internal.env.TMUX",
@@ -4130,13 +4102,6 @@
    "title": "Attaching to tmux",
    "section": "guides"
   },
-  {
-   "port": "py",
-   "symbol": "libtmux._internal.env.TMUX_PANE",
-   "page": "/guides/testing-with-libtmux/",
-   "title": "Testing with libtmux",
-   "section": "guides"
-  },
   {
    "port": "py",
    "symbol": "libtmux._internal.env.TMUX_PANE",
@@ -4172,13 +4137,6 @@
    "title": "Filtering and queries",
    "section": "concepts"
   },
-  {
-   "port": "py",
-   "symbol": "libtmux._internal.query_list.QueryList.filter",
-   "page": "/guides/querying-and-filtering/",
-   "title": "Filtering and querying, in practice",
-   "section": "guides"
-  },
   {
    "port": "py",
    "symbol": "libtmux.constants.ResizeAdjustmentDirection.Up",
@@ -4246,16 +4204,9 @@
    "port": "py",
    "symbol": "libtmux.pane.Pane",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
-  {
-   "port": "py",
-   "symbol": "libtmux.pane.Pane.capture_pane",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
   {
    "port": "py",
    "symbol": "libtmux.pane.Pane.from_env",
@@ -4368,18 +4319,11 @@
    "title": "Python workspace internal API",
    "section": "ports"
   },
-  {
-   "port": "py",
-   "symbol": "libtmux.server.Server",
-   "page": "/swift/latest/workspace/cli/shell/",
-   "title": "tmuxp shell",
-   "section": "ports"
-  },
   {
    "port": "py",
    "symbol": "libtmux.server.Server",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -4396,13 +4340,6 @@
    "title": "Socket and servers",
    "section": "topics"
   },
-  {
-   "port": "py",
-   "symbol": "libtmux.server.Server.from_env",
-   "page": "/guides/attaching-to-tmux/",
-   "title": "Attaching to tmux",
-   "section": "guides"
-  },
   {
    "port": "py",
    "symbol": "libtmux.server.Server.from_env",
@@ -4440,10 +4377,10 @@
   },
   {
    "port": "py",
-   "symbol": "libtmux.server.Server.search_sessions",
-   "page": "/guides/querying-and-filtering/",
-   "title": "Filtering and querying, in practice",
-   "section": "guides"
+   "symbol": "libtmux.server.Server.sessions",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
   },
   {
    "port": "py",
@@ -4473,13 +4410,6 @@
    "title": "Socket and servers",
    "section": "topics"
   },
-  {
-   "port": "py",
-   "symbol": "libtmux.server.Server.tmux_bin",
-   "page": "/swift/latest/workspace/cli/shell/",
-   "title": "tmuxp shell",
-   "section": "ports"
-  },
   {
    "port": "py",
    "symbol": "libtmux.server.Server.unset_environment",
@@ -4490,9 +4420,9 @@
   {
    "port": "py",
    "symbol": "libtmux.server.Server.wait_for",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
+   "page": "/topics/pane-interaction/",
+   "title": "Pane interaction",
+   "section": "topics"
   },
   {
    "port": "py",
@@ -4533,7 +4463,7 @@
    "port": "py",
    "symbol": "libtmux.session.Session",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -4557,6 +4487,13 @@
    "title": "Environment",
    "section": "topics"
   },
+  {
+   "port": "py",
+   "symbol": "libtmux.session.Session.pane_id",
+   "page": "/topics/format-tokens/",
+   "title": "Format-token fields",
+   "section": "topics"
+  },
   {
    "port": "py",
    "symbol": "libtmux.session.Session.panes",
@@ -4578,6 +4515,13 @@
    "title": "Environment",
    "section": "topics"
   },
+  {
+   "port": "py",
+   "symbol": "libtmux.session.Session.windows",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
+  },
   {
    "port": "py",
    "symbol": "libtmux.session.Session.windows",
@@ -4610,7 +4554,7 @@
    "port": "py",
    "symbol": "libtmux.window.Window",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -4641,6 +4585,13 @@
    "title": "Filtering and queries",
    "section": "concepts"
   },
+  {
+   "port": "py",
+   "symbol": "libtmux.window.Window.panes",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
+  },
   {
    "port": "py",
    "symbol": "libtmux.window.Window.panes",
@@ -4662,6 +4613,13 @@
    "title": "Shell completion",
    "section": "ports"
   },
+  {
+   "port": "py",
+   "symbol": "tmuxp.cli.create_parser",
+   "page": "/py/latest/workspace/internals/documentation/",
+   "title": "Workspace reference generation",
+   "section": "ports"
+  },
   {
    "port": "py",
    "symbol": "tmuxp.cli.search.SearchPattern.regex",
@@ -4669,95 +4627,81 @@
    "title": "Filtering and queries",
    "section": "concepts"
   },
-  {
-   "port": "py",
-   "symbol": "tmuxp.cli.search.WorkspaceFields.windows",
-   "page": "/ts/latest/workspace/configuration/session/",
-   "title": "Session configuration",
-   "section": "ports"
-  },
   {
    "port": "py",
    "symbol": "tmuxp.cli.shell.CLIShellNamespace.shell",
-   "page": "/ts/latest/workspace/reference/compatibility/",
-   "title": "tmuxp compatibility and port status",
-   "section": "ports"
-  },
-  {
-   "port": "py",
-   "symbol": "tmuxp.plugin.TmuxpPlugin.after_window_finished",
-   "page": "/py/latest/workspace/configuration/hooks/",
-   "title": "Workspace hooks and builders",
+   "page": "/cxx/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
    "section": "ports"
   },
   {
    "port": "py",
-   "symbol": "tmuxp.plugin.TmuxpPlugin.before_script",
-   "page": "/go/latest/workspace/",
-   "title": "tmux workspace manager for Go",
+   "symbol": "tmuxp.cli.shell.CLIShellNamespace.shell",
+   "page": "/dotnet/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
    "section": "ports"
   },
   {
    "port": "py",
-   "symbol": "tmuxp.plugin.TmuxpPlugin.before_script",
-   "page": "/go/latest/workspace/cli/load/",
-   "title": "tmuxp load",
+   "symbol": "tmuxp.cli.shell.CLIShellNamespace.shell",
+   "page": "/go/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
    "section": "ports"
   },
   {
    "port": "py",
-   "symbol": "tmuxp.plugin.TmuxpPlugin.before_script",
-   "page": "/go/latest/workspace/guides/installation/",
-   "title": "Install and load a workspace",
+   "symbol": "tmuxp.cli.shell.CLIShellNamespace.shell",
+   "page": "/java/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
    "section": "ports"
   },
   {
    "port": "py",
-   "symbol": "tmuxp.plugin.TmuxpPlugin.before_script",
-   "page": "/go/latest/workspace/internals/",
-   "title": "Go workspace internals",
+   "symbol": "tmuxp.cli.shell.CLIShellNamespace.shell",
+   "page": "/rs/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
    "section": "ports"
   },
   {
    "port": "py",
-   "symbol": "tmuxp.plugin.TmuxpPlugin.before_script",
-   "page": "/go/latest/workspace/internals/topics/",
-   "title": "Go workspace builder behavior",
+   "symbol": "tmuxp.cli.shell.CLIShellNamespace.shell",
+   "page": "/swift/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
    "section": "ports"
   },
   {
    "port": "py",
-   "symbol": "tmuxp.plugin.TmuxpPlugin.before_script",
-   "page": "/ts/latest/workspace/configuration/hooks/",
-   "title": "Workspace hooks and builders",
+   "symbol": "tmuxp.cli.shell.CLIShellNamespace.shell",
+   "page": "/ts/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
    "section": "ports"
   },
   {
    "port": "py",
-   "symbol": "tmuxp.plugin.TmuxpPlugin.before_script",
-   "page": "/ts/latest/workspace/reference/compatibility/",
-   "title": "tmuxp compatibility and port status",
+   "symbol": "tmuxp.plugin.TmuxpPlugin.after_window_finished",
+   "page": "/py/latest/workspace/configuration/hooks/",
+   "title": "Bootstrap scripts and extensions",
    "section": "ports"
   },
   {
    "port": "py",
    "symbol": "tmuxp.plugin.TmuxpPlugin.before_workspace_builder",
    "page": "/py/latest/workspace/configuration/hooks/",
-   "title": "Workspace hooks and builders",
+   "title": "Bootstrap scripts and extensions",
    "section": "ports"
   },
   {
    "port": "py",
    "symbol": "tmuxp.plugin.TmuxpPlugin.on_window_create",
    "page": "/py/latest/workspace/configuration/hooks/",
-   "title": "Workspace hooks and builders",
+   "title": "Bootstrap scripts and extensions",
    "section": "ports"
   },
   {
    "port": "py",
    "symbol": "tmuxp.plugin.TmuxpPlugin.reattach",
    "page": "/py/latest/workspace/configuration/hooks/",
-   "title": "Workspace hooks and builders",
+   "title": "Bootstrap scripts and extensions",
    "section": "ports"
   },
   {
@@ -4809,6 +4753,20 @@
    "title": "Python workspace internal API",
    "section": "ports"
   },
+  {
+   "port": "py",
+   "symbol": "tmuxp.workspace.freezer.freeze",
+   "page": "/py/latest/workspace/reference/exit-codes/",
+   "title": "Exit codes and errors",
+   "section": "ports"
+  },
+  {
+   "port": "py",
+   "symbol": "tmuxp.workspace.freezer.freeze",
+   "page": "/py/latest/workspace/reference/output/",
+   "title": "Output formats",
+   "section": "ports"
+  },
   {
    "port": "py",
    "symbol": "tmuxp.workspace.freezer.inline",
@@ -4858,6 +4816,27 @@
    "title": "Rust workspace builder API",
    "section": "ports"
   },
+  {
+   "port": "rs",
+   "symbol": "config.PaneConfig.shell",
+   "page": "/rs/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
+  },
+  {
+   "port": "rs",
+   "symbol": "config.PaneConfig.shell",
+   "page": "/rs/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
+   "section": "ports"
+  },
+  {
+   "port": "rs",
+   "symbol": "config.PaneConfig.shell",
+   "page": "/rs/latest/workspace/reference/compatibility/",
+   "title": "Runtime and configuration support",
+   "section": "ports"
+  },
   {
    "port": "rs",
    "symbol": "config.WindowConfig",
@@ -4865,11 +4844,32 @@
    "title": "Rust workspace builder API",
    "section": "ports"
   },
+  {
+   "port": "rs",
+   "symbol": "config.WindowConfig.panes",
+   "page": "/rs/latest/workspace/cli/import-tmuxinator/",
+   "title": "Import from tmuxinator",
+   "section": "ports"
+  },
+  {
+   "port": "rs",
+   "symbol": "config.WindowConfig.panes",
+   "page": "/rs/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
+  },
+  {
+   "port": "rs",
+   "symbol": "config.WindowConfig.window_index",
+   "page": "/rs/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
+   "section": "ports"
+  },
   {
    "port": "rs",
    "symbol": "config.WindowConfig.window_shell",
-   "page": "/rs/latest/workspace/reference/compatibility/",
-   "title": "tmuxp compatibility and port status",
+   "page": "/rs/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
    "section": "ports"
   },
   {
@@ -4923,16 +4923,16 @@
   },
   {
    "port": "rs",
-   "symbol": "config.Workspace.session_name",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
+   "symbol": "config.Workspace.global_options",
+   "page": "/rs/latest/workspace/configuration/session/",
+   "title": "Session configuration",
+   "section": "ports"
   },
   {
    "port": "rs",
    "symbol": "config.Workspace.session_name",
-   "page": "/rs/latest/workspace/reference/output/",
-   "title": "JSON, NDJSON, and semantic color",
+   "page": "/rs/latest/workspace/configuration/session/",
+   "title": "Session configuration",
    "section": "ports"
   },
   {
@@ -4963,6 +4963,20 @@
    "title": "Rust workspace builder API",
    "section": "ports"
   },
+  {
+   "port": "rs",
+   "symbol": "config.Workspace.windows",
+   "page": "/rs/latest/workspace/configuration/session/",
+   "title": "Session configuration",
+   "section": "ports"
+  },
+  {
+   "port": "rs",
+   "symbol": "config.Workspace.windows",
+   "page": "/rs/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
+   "section": "ports"
+  },
   {
    "port": "rs",
    "symbol": "error.ControlModeErrorKind",
@@ -5084,45 +5098,10 @@
   },
   {
    "port": "rs",
-   "symbol": "mcp.tail.Cursor.decode",
-   "page": "/lua/latest/guides/query/",
-   "title": "Query captured data",
-   "section": "guides"
-  },
-  {
-   "port": "rs",
-   "symbol": "mcp.tail.Cursor.encode",
-   "page": "/lua/latest/guides/query/",
-   "title": "Query captured data",
-   "section": "guides"
-  },
-  {
-   "port": "rs",
-   "symbol": "mcp.views.Since",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
-  {
-   "port": "rs",
-   "symbol": "mcp.views.Snapshot.cursor_x",
-   "page": "/examples/workspace-from-file/",
-   "title": "Build a workspace from a file",
-   "section": "examples"
-  },
-  {
-   "port": "rs",
-   "symbol": "mcp.views.Snapshot.cursor_y",
-   "page": "/examples/workspace-from-file/",
-   "title": "Build a workspace from a file",
-   "section": "examples"
-  },
-  {
-   "port": "rs",
-   "symbol": "mcp.views.Snapshot.in_mode",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
-   "section": "topics"
+   "symbol": "options.generated.EDITOR",
+   "page": "/rs/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
+   "section": "ports"
   },
   {
    "port": "rs",
@@ -5222,13 +5201,6 @@
    "title": "Options and hooks",
    "section": "topics"
   },
-  {
-   "port": "rs",
-   "symbol": "pane.Pane.wait_for_text",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
   {
    "port": "rs",
    "symbol": "pane.Pane.wait_for_text",
@@ -5243,41 +5215,6 @@
    "title": "Traversal",
    "section": "topics"
   },
-  {
-   "port": "rs",
-   "symbol": "pane.Pane.window_id",
-   "page": "/lua/latest/guides/control/",
-   "title": "Observing a session",
-   "section": "guides"
-  },
-  {
-   "port": "rs",
-   "symbol": "pane.Pane.window_id",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
-  {
-   "port": "rs",
-   "symbol": "pane.Pane.window_id",
-   "page": "/lua/latest/guides/snapshots/",
-   "title": "Capture server state",
-   "section": "guides"
-  },
-  {
-   "port": "rs",
-   "symbol": "pane.Pane.window_id",
-   "page": "/topics/format-tokens/",
-   "title": "Format-token fields",
-   "section": "topics"
-  },
-  {
-   "port": "rs",
-   "symbol": "pane.PaneWait.Dead",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
   {
    "port": "rs",
    "symbol": "plan.Plan.preview",
@@ -5294,10 +5231,10 @@
   },
   {
    "port": "rs",
-   "symbol": "plan.run.StepOutcome.outcomes",
-   "page": "/lua/latest/guides/commands/",
-   "title": "Execute tmux commands",
-   "section": "guides"
+   "symbol": "query.FilterExpr.and",
+   "page": "/concepts/queries/",
+   "title": "Filtering and queries",
+   "section": "concepts"
   },
   {
    "port": "rs",
@@ -5369,27 +5306,6 @@
    "title": "Environment",
    "section": "topics"
   },
-  {
-   "port": "rs",
-   "symbol": "server.Server.generation",
-   "page": "/lua/latest/guides/control/",
-   "title": "Observing a session",
-   "section": "guides"
-  },
-  {
-   "port": "rs",
-   "symbol": "server.Server.generation",
-   "page": "/ruby/latest/guides/async/",
-   "title": "libtmux-async",
-   "section": "guides"
-  },
-  {
-   "port": "rs",
-   "symbol": "server.Server.generation",
-   "page": "/ruby/latest/guides/core/",
-   "title": "libtmux",
-   "section": "guides"
-  },
   {
    "port": "rs",
    "symbol": "server.Server.is_alive",
@@ -5488,13 +5404,6 @@
    "title": "Traversal",
    "section": "topics"
   },
-  {
-   "port": "rs",
-   "symbol": "session.Session.search_windows",
-   "page": "/concepts/queries/",
-   "title": "Filtering and queries",
-   "section": "concepts"
-  },
   {
    "port": "rs",
    "symbol": "session.Session.set_environment",
@@ -5621,13 +5530,6 @@
    "title": "Testing with libtmux",
    "section": "guides"
   },
-  {
-   "port": "rs",
-   "symbol": "test.retry_until",
-   "page": "/topics/pane-interaction/",
-   "title": "Pane interaction",
-   "section": "topics"
-  },
   {
    "port": "rs",
    "symbol": "test.retry_until",
@@ -5642,6 +5544,27 @@
    "title": "Rust workspace builder examples",
    "section": "ports"
   },
+  {
+   "port": "rs",
+   "symbol": "test.TestServer",
+   "page": "/topics/context-managers/",
+   "title": "Ownership and cleanup",
+   "section": "topics"
+  },
+  {
+   "port": "rs",
+   "symbol": "test.TestServer.server",
+   "page": "/rs/latest/workspace/cli/shell/",
+   "title": "Evaluate in a workspace",
+   "section": "ports"
+  },
+  {
+   "port": "rs",
+   "symbol": "test.TestServer.shutdown",
+   "page": "/topics/context-managers/",
+   "title": "Ownership and cleanup",
+   "section": "topics"
+  },
   {
    "port": "rs",
    "symbol": "window.Window",
@@ -5670,13 +5593,6 @@
    "title": "Traversal",
    "section": "topics"
   },
-  {
-   "port": "rs",
-   "symbol": "window.Window.search_panes",
-   "page": "/concepts/queries/",
-   "title": "Filtering and queries",
-   "section": "concepts"
-  },
   {
    "port": "rs",
    "symbol": "window.Window.session",
@@ -5812,49 +5728,14 @@
   },
   {
    "port": "ruby",
-   "symbol": "LibTmux::CommandResult#text",
-   "page": "/lua/latest/guides/buffers/",
-   "title": "Read and paste named buffers",
-   "section": "guides"
-  },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::CommandResult#text",
-   "page": "/lua/latest/guides/panes/",
-   "title": "Pane operations",
+   "symbol": "LibTmux::DeadlineExceeded",
+   "page": "/ruby/latest/guides/ownership-errors/",
+   "title": "Ownership and errors",
    "section": "guides"
   },
   {
    "port": "ruby",
-   "symbol": "LibTmux::DeadlineExceeded",
-   "page": "/ruby/latest/guides/ownership-errors/",
-   "title": "Ownership and errors",
-   "section": "guides"
-  },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::Endpoint#socket_path",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::Endpoint#socket_path",
-   "page": "/lua/latest/guides/snapshots/",
-   "title": "Capture server state",
-   "section": "guides"
-  },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::Endpoint#socket_path",
-   "page": "/topics/socket-and-servers/",
-   "title": "Socket and servers",
-   "section": "topics"
-  },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::FieldDecodeError",
+   "symbol": "LibTmux::FieldDecodeError",
    "page": "/ruby/latest/guides/ownership-errors/",
    "title": "Ownership and errors",
    "section": "guides"
@@ -5978,13 +5859,6 @@
    "title": "libtmux",
    "section": "guides"
   },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::PaneSnapshot#dead_status",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
   {
    "port": "ruby",
    "symbol": "LibTmux::Selection",
@@ -6041,6 +5915,13 @@
    "title": "libtmux for Ruby",
    "section": "guides"
   },
+  {
+   "port": "ruby",
+   "symbol": "LibTmux::Server.open",
+   "page": "/ruby/latest/guides/overview/",
+   "title": "libtmux for Ruby",
+   "section": "guides"
+  },
   {
    "port": "ruby",
    "symbol": "LibTmux::Session#new_window",
@@ -6125,27 +6006,6 @@
    "title": "libtmux-workspace",
    "section": "workspace"
   },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::Workspace::Plan::Step#effect",
-   "page": "/lua/latest/guides/commands/",
-   "title": "Execute tmux commands",
-   "section": "guides"
-  },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::Workspace::Plan::Step#effect",
-   "page": "/lua/latest/guides/runtime/",
-   "title": "Runtime ownership",
-   "section": "guides"
-  },
-  {
-   "port": "ruby",
-   "symbol": "LibTmux::Workspace::Plan::Step#operation",
-   "page": "/lua/latest/guides/query/",
-   "title": "Query captured data",
-   "section": "guides"
-  },
   {
    "port": "ruby",
    "symbol": "LibTmux::Workspace::Plan#apply",
@@ -6202,13 +6062,6 @@
    "title": "libtmux-workspace",
    "section": "workspace"
   },
-  {
-   "port": "swift",
-   "symbol": "ControlNotificationStream.drop(while:)",
-   "page": "/topics/context-managers/",
-   "title": "Context managers",
-   "section": "topics"
-  },
   {
    "port": "swift",
    "symbol": "ControlSession",
@@ -6216,13 +6069,6 @@
    "title": "Errors and exceptions",
    "section": "topics"
   },
-  {
-   "port": "swift",
-   "symbol": "ControlSession.send(_:)",
-   "page": "/concepts/transports/",
-   "title": "Control mode vs one-shot",
-   "section": "concepts"
-  },
   {
    "port": "swift",
    "symbol": "ControlSession.watch(_:)",
@@ -6237,13 +6083,6 @@
    "title": "Socket and servers",
    "section": "topics"
   },
-  {
-   "port": "swift",
-   "symbol": "FilterSchema.Model.fields",
-   "page": "/lua/latest/guides/snapshots/",
-   "title": "Capture server state",
-   "section": "guides"
-  },
   {
    "port": "swift",
    "symbol": "FormatSubscription",
@@ -6258,6 +6097,13 @@
    "title": "Options and hooks",
    "section": "topics"
   },
+  {
+   "port": "swift",
+   "symbol": "JSONValue.null",
+   "page": "/swift/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "MCPRequestHandler",
@@ -6317,29 +6163,22 @@
   {
    "port": "swift",
    "symbol": "PanePlan",
-   "page": "/swift/latest/workspace/internals/topics/",
-   "title": "Swift workspace builder behavior",
+   "page": "/swift/latest/workspace/internals/guides/",
+   "title": "Use the Swift workspace builder",
    "section": "ports"
   },
   {
    "port": "swift",
    "symbol": "PanePlan",
-   "page": "/swift/latest/workspace/reference/",
-   "title": "Swift workspace builder API",
+   "page": "/swift/latest/workspace/internals/topics/",
+   "title": "Swift workspace builder behavior",
    "section": "ports"
   },
   {
    "port": "swift",
-   "symbol": "Server",
-   "page": "/guides/testing-with-libtmux/",
-   "title": "Testing with libtmux",
-   "section": "guides"
-  },
-  {
-   "port": "swift",
-   "symbol": "Server",
-   "page": "/swift/latest/mcp/examples/",
-   "title": "Swift MCP examples",
+   "symbol": "PanePlan",
+   "page": "/swift/latest/workspace/reference/",
+   "title": "Swift workspace builder API",
    "section": "ports"
   },
   {
@@ -6363,19 +6202,40 @@
    "title": "Socket and servers",
    "section": "topics"
   },
+  {
+   "port": "swift",
+   "symbol": "Server.connected(attachingTo:_:)",
+   "page": "/concepts/transports/",
+   "title": "Control mode vs one-shot",
+   "section": "concepts"
+  },
   {
    "port": "swift",
    "symbol": "Server.environment(_:)",
-   "page": "/lua/latest/guides/creation/",
-   "title": "Create sessions, windows and panes",
-   "section": "guides"
+   "page": "/swift/latest/workspace/configuration/environment/",
+   "title": "Workspace environment",
+   "section": "ports"
   },
   {
    "port": "swift",
    "symbol": "Server.environment(_:)",
-   "page": "/lua/latest/guides/topology/",
-   "title": "Topology operations",
-   "section": "guides"
+   "page": "/swift/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
+  },
+  {
+   "port": "swift",
+   "symbol": "Server.environment(_:)",
+   "page": "/swift/latest/workspace/configuration/session/",
+   "title": "Session configuration",
+   "section": "ports"
+  },
+  {
+   "port": "swift",
+   "symbol": "Server.environment(_:)",
+   "page": "/swift/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
+   "section": "ports"
   },
   {
    "port": "swift",
@@ -6405,25 +6265,11 @@
    "title": "Socket and servers",
    "section": "topics"
   },
-  {
-   "port": "swift",
-   "symbol": "Server.kill(_:)",
-   "page": "/lua/latest/guides/panes/",
-   "title": "Pane operations",
-   "section": "guides"
-  },
-  {
-   "port": "swift",
-   "symbol": "Server.kill(_:)",
-   "page": "/ruby/latest/guides/core/",
-   "title": "libtmux",
-   "section": "guides"
-  },
   {
    "port": "swift",
    "symbol": "Server.kill(_:)",
    "page": "/topics/context-managers/",
-   "title": "Context managers",
+   "title": "Ownership and cleanup",
    "section": "topics"
   },
   {
@@ -6447,13 +6293,6 @@
    "title": "Options and hooks",
    "section": "topics"
   },
-  {
-   "port": "swift",
-   "symbol": "Server.refresh(_:)",
-   "page": "/concepts/server-session-window-pane/",
-   "title": "Server, session, window, pane",
-   "section": "concepts"
-  },
   {
    "port": "swift",
    "symbol": "Server.removeEnvironment(_:in:)",
@@ -6468,20 +6307,6 @@
    "title": "Options and hooks",
    "section": "topics"
   },
-  {
-   "port": "swift",
-   "symbol": "Server.select(_:)",
-   "page": "/lua/latest/guides/query/",
-   "title": "Query captured data",
-   "section": "guides"
-  },
-  {
-   "port": "swift",
-   "symbol": "Server.select(_:)",
-   "page": "/lua/latest/guides/topology/",
-   "title": "Topology operations",
-   "section": "guides"
-  },
   {
    "port": "swift",
    "symbol": "Server.sendKeys(_:to:literally:)",
@@ -6489,6 +6314,13 @@
    "title": "Pane interaction",
    "section": "topics"
   },
+  {
+   "port": "swift",
+   "symbol": "Server.sessions()",
+   "page": "/topics/traversal/",
+   "title": "Traversal",
+   "section": "topics"
+  },
   {
    "port": "swift",
    "symbol": "Server.setEnvironment(_:to:in:)",
@@ -6520,30 +6352,9 @@
   {
    "port": "swift",
    "symbol": "Server.snapshot()",
-   "page": "/topics/architecture/",
-   "title": "Architecture",
-   "section": "topics"
-  },
-  {
-   "port": "swift",
-   "symbol": "Server.split(_:direction:size:startDirectory:)",
-   "page": "/concepts/workspaces/",
-   "title": "Workspaces",
-   "section": "concepts"
-  },
-  {
-   "port": "swift",
-   "symbol": "Server.swap(_:with:)",
-   "page": "/lua/latest/guides/panes/",
-   "title": "Pane operations",
-   "section": "guides"
-  },
-  {
-   "port": "swift",
-   "symbol": "Server.swap(_:with:)",
-   "page": "/lua/latest/guides/topology/",
-   "title": "Topology operations",
-   "section": "guides"
+   "page": "/swift/latest/workspace/internals/guides/",
+   "title": "Use the Swift workspace builder",
+   "section": "ports"
   },
   {
    "port": "swift",
@@ -6566,13 +6377,6 @@
    "title": "Options and hooks",
    "section": "topics"
   },
-  {
-   "port": "swift",
-   "symbol": "Server.wait(for:)",
-   "page": "/guides/capturing-output/",
-   "title": "Capturing output",
-   "section": "guides"
-  },
   {
    "port": "swift",
    "symbol": "Server.wait(for:)",
@@ -6580,13 +6384,6 @@
    "title": "Waiting and retrying",
    "section": "topics"
   },
-  {
-   "port": "swift",
-   "symbol": "Server.waitForOutput(in:matching:stoppingAt:requiringFreshOutput:startingAt:timeout:tailLimit:)",
-   "page": "/examples/capture-pane-output/",
-   "title": "Capture pane output",
-   "section": "examples"
-  },
   {
    "port": "swift",
    "symbol": "Server.waitForOutput(in:matching:stoppingAt:requiringFreshOutput:startingAt:timeout:tailLimit:)",
@@ -6601,48 +6398,6 @@
    "title": "Swift MCP API",
    "section": "ports"
   },
-  {
-   "port": "swift",
-   "symbol": "ServerConfiguration.errors",
-   "page": "/swift/latest/workspace/reference/exit-codes/",
-   "title": "Exit codes and errors",
-   "section": "ports"
-  },
-  {
-   "port": "swift",
-   "symbol": "ServerConfiguration.errors",
-   "page": "/swift/latest/workspace/reference/output/",
-   "title": "JSON, NDJSON, and semantic color",
-   "section": "ports"
-  },
-  {
-   "port": "swift",
-   "symbol": "ServerProvenance.unknown",
-   "page": "/lua/latest/guides/commands/",
-   "title": "Execute tmux commands",
-   "section": "guides"
-  },
-  {
-   "port": "swift",
-   "symbol": "ServerProvenance.unknown",
-   "page": "/lua/latest/guides/runtime/",
-   "title": "Runtime ownership",
-   "section": "guides"
-  },
-  {
-   "port": "swift",
-   "symbol": "ServerProvenance.unknown",
-   "page": "/lua/latest/guides/settings/",
-   "title": "Options and hooks",
-   "section": "guides"
-  },
-  {
-   "port": "swift",
-   "symbol": "ServerProvenance.unknown",
-   "page": "/ruby/latest/guides/execution-modes/",
-   "title": "Execution modes",
-   "section": "guides"
-  },
   {
    "port": "swift",
    "symbol": "Session",
@@ -6692,6 +6447,13 @@
    "title": "Format-token fields",
    "section": "topics"
   },
+  {
+   "port": "swift",
+   "symbol": "TmuxCommandList.commands",
+   "page": "/swift/latest/workspace/cli/import-teamocil/",
+   "title": "Import from Teamocil",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "TmuxContext",
@@ -6708,9 +6470,16 @@
   },
   {
    "port": "swift",
-   "symbol": "TmuxHook.command",
-   "page": "/swift/latest/mcp/guides/",
-   "title": "Connect a Swift MCP client",
+   "symbol": "TmuxShellCommand.enter",
+   "page": "/swift/latest/workspace/configuration/commands/",
+   "title": "Workspace commands",
+   "section": "ports"
+  },
+  {
+   "port": "swift",
+   "symbol": "TmuxShellCommand.enter",
+   "page": "/swift/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
    "section": "ports"
   },
   {
@@ -6734,6 +6503,13 @@
    "title": "Swift MCP API",
    "section": "ports"
   },
+  {
+   "port": "swift",
+   "symbol": "ToolAuthority",
+   "page": "/swift/latest/mcp/examples/",
+   "title": "Swift MCP examples",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "ToolAuthority",
@@ -6741,6 +6517,13 @@
    "title": "Swift MCP API",
    "section": "ports"
   },
+  {
+   "port": "swift",
+   "symbol": "ToolError",
+   "page": "/swift/latest/mcp/examples/",
+   "title": "Swift MCP examples",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "ToolError",
@@ -6804,6 +6587,13 @@
    "title": "Traversal",
    "section": "topics"
   },
+  {
+   "port": "swift",
+   "symbol": "WindowPlan",
+   "page": "/swift/latest/workspace/internals/guides/",
+   "title": "Use the Swift workspace builder",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "WindowPlan",
@@ -6820,7 +6610,21 @@
   },
   {
    "port": "swift",
-   "symbol": "withTmuxServer(socketFileName:_:)",
+   "symbol": "WindowPlan.panes",
+   "page": "/swift/latest/workspace/cli/import-tmuxinator/",
+   "title": "Import from tmuxinator",
+   "section": "ports"
+  },
+  {
+   "port": "swift",
+   "symbol": "WindowPlan.panes",
+   "page": "/swift/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
+  },
+  {
+   "port": "swift",
+   "symbol": "WindowPlan.panes",
    "page": "/swift/latest/workspace/internals/guides/",
    "title": "Use the Swift workspace builder",
    "section": "ports"
@@ -6832,6 +6636,13 @@
    "title": "Swift workspace internals",
    "section": "ports"
   },
+  {
+   "port": "swift",
+   "symbol": "Workspace",
+   "page": "/swift/latest/workspace/internals/guides/",
+   "title": "Use the Swift workspace builder",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "Workspace",
@@ -6853,6 +6664,13 @@
    "title": "Build a workspace from a file",
    "section": "examples"
   },
+  {
+   "port": "swift",
+   "symbol": "Workspace.decode(json:)",
+   "page": "/swift/latest/workspace/internals/examples/",
+   "title": "Swift workspace builder examples",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "Workspace.decode(json:)",
@@ -6888,6 +6706,27 @@
    "title": "Swift workspace builder API",
    "section": "ports"
   },
+  {
+   "port": "swift",
+   "symbol": "Workspace.windows",
+   "page": "/swift/latest/workspace/configuration/session/",
+   "title": "Session configuration",
+   "section": "ports"
+  },
+  {
+   "port": "swift",
+   "symbol": "Workspace.windows",
+   "page": "/swift/latest/workspace/configuration/windows/",
+   "title": "Window configuration",
+   "section": "ports"
+  },
+  {
+   "port": "swift",
+   "symbol": "Workspace.windows",
+   "page": "/swift/latest/workspace/internals/guides/",
+   "title": "Use the Swift workspace builder",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "WorkspaceBuilder",
@@ -6909,6 +6748,13 @@
    "title": "Swift workspace internals",
    "section": "ports"
   },
+  {
+   "port": "swift",
+   "symbol": "WorkspaceBuilder.build(_:on:)",
+   "page": "/swift/latest/workspace/internals/guides/",
+   "title": "Use the Swift workspace builder",
+   "section": "ports"
+  },
   {
    "port": "swift",
    "symbol": "WorkspaceBuilder.build(_:on:)",
@@ -6965,6 +6811,13 @@
    "title": "TypeScript workspace internals",
    "section": "ports"
   },
+  {
+   "port": "ts",
+   "symbol": "builder.applyWorkspace",
+   "page": "/ts/latest/workspace/internals/examples/",
+   "title": "TypeScript workspace builder examples",
+   "section": "ports"
+  },
   {
    "port": "ts",
    "symbol": "builder.applyWorkspace",
@@ -7021,20 +6874,6 @@
    "title": "TypeScript workspace builder behavior",
    "section": "ports"
   },
-  {
-   "port": "ts",
-   "symbol": "common.CommandOutcome.status",
-   "page": "/ts/latest/workspace/reference/output/",
-   "title": "JSON, NDJSON, and semantic color",
-   "section": "ports"
-  },
-  {
-   "port": "ts",
-   "symbol": "common.LogicalRefBase.connection",
-   "page": "/concepts/transports/",
-   "title": "Control mode vs one-shot",
-   "section": "concepts"
-  },
   {
    "port": "ts",
    "symbol": "config.parseWorkspace",
@@ -7133,6 +6972,13 @@
    "title": "TypeScript MCP API",
    "section": "ports"
   },
+  {
+   "port": "ts",
+   "symbol": "operation_options.ApplyWorkspaceOptions.commands",
+   "page": "/ts/latest/workspace/cli/import-teamocil/",
+   "title": "Import from Teamocil",
+   "section": "ports"
+  },
   {
    "port": "ts",
    "symbol": "pane.Pane",
@@ -7217,27 +7063,6 @@
    "title": "TypeScript workspace builder API",
    "section": "ports"
   },
-  {
-   "port": "ts",
-   "symbol": "selection.ClientWhere.prefix",
-   "page": "/lua/latest/guides/options/",
-   "title": "tmux option and hook reference",
-   "section": "guides"
-  },
-  {
-   "port": "ts",
-   "symbol": "selection.ClientWhere.readonly",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
-  {
-   "port": "ts",
-   "symbol": "selection.ClientWhere.written",
-   "page": "/topics/errors-and-exceptions/",
-   "title": "Errors and exceptions",
-   "section": "topics"
-  },
   {
    "port": "ts",
    "symbol": "selection.decodeWhereDocument",
@@ -7252,34 +7077,6 @@
    "title": "Filtering and queries",
    "section": "concepts"
   },
-  {
-   "port": "ts",
-   "symbol": "selection.PaneWhere.bottom",
-   "page": "/lua/latest/guides/options/",
-   "title": "tmux option and hook reference",
-   "section": "guides"
-  },
-  {
-   "port": "ts",
-   "symbol": "selection.PaneWhere.right",
-   "page": "/lua/latest/guides/creation/",
-   "title": "Create sessions, windows and panes",
-   "section": "guides"
-  },
-  {
-   "port": "ts",
-   "symbol": "selection.PaneWhere.right",
-   "page": "/lua/latest/guides/options/",
-   "title": "tmux option and hook reference",
-   "section": "guides"
-  },
-  {
-   "port": "ts",
-   "symbol": "selection.PaneWhere.synchronized",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
-   "section": "guides"
-  },
   {
    "port": "ts",
    "symbol": "selection.Selection",
@@ -7317,16 +7114,9 @@
   },
   {
    "port": "ts",
-   "symbol": "selection.Selection.where",
-   "page": "/guides/querying-and-filtering/",
-   "title": "Filtering and querying, in practice",
-   "section": "guides"
-  },
-  {
-   "port": "ts",
-   "symbol": "selection.SessionWhere.grouped",
-   "page": "/lua/latest/guides/fields/",
-   "title": "tmux field catalog",
+   "symbol": "server.Server",
+   "page": "/guides/testing-with-libtmux/",
+   "title": "Testing with libtmux",
    "section": "guides"
   },
   {
@@ -7350,13 +7140,6 @@
    "title": "TypeScript workspace internals",
    "section": "ports"
   },
-  {
-   "port": "ts",
-   "symbol": "server.Server",
-   "page": "/ts/latest/workspace/internals/examples/",
-   "title": "TypeScript workspace builder examples",
-   "section": "ports"
-  },
   {
    "port": "ts",
    "symbol": "server.Server",
@@ -7392,6 +7175,20 @@
    "title": "Socket and servers",
    "section": "topics"
   },
+  {
+   "port": "ts",
+   "symbol": "server.Server.newSession",
+   "page": "/ts/latest/mcp/examples/",
+   "title": "TypeScript MCP examples",
+   "section": "ports"
+  },
+  {
+   "port": "ts",
+   "symbol": "server.Server.newSession",
+   "page": "/ts/latest/workspace/internals/examples/",
+   "title": "TypeScript workspace builder examples",
+   "section": "ports"
+  },
   {
    "port": "ts",
    "symbol": "server.Server.pipeline",
@@ -7534,10 +7331,17 @@
   },
   {
    "port": "ts",
-   "symbol": "types.ResizeOptions.amount",
-   "page": "/lua/latest/guides/topology/",
-   "title": "Topology operations",
-   "section": "guides"
+   "symbol": "types.SendKeysOptions.enter",
+   "page": "/ts/latest/workspace/configuration/commands/",
+   "title": "Workspace commands",
+   "section": "ports"
+  },
+  {
+   "port": "ts",
+   "symbol": "types.SendKeysOptions.enter",
+   "page": "/ts/latest/workspace/configuration/panes/",
+   "title": "Pane configuration",
+   "section": "ports"
   },
   {
    "port": "ts",
@@ -7546,13 +7350,6 @@
    "title": "Waiting and retrying",
    "section": "topics"
   },
-  {
-   "port": "ts",
-   "symbol": "types.SetEnvironmentOptions.hidden",
-   "page": "/lua/latest/guides/environment/",
-   "title": "Persistent environment",
-   "section": "guides"
-  },
   {
    "port": "ts",
    "symbol": "window.Window",
@@ -7585,73 +7382,38 @@
  "dangling": [
   {
    "port": "lua",
-   "text": "list_environment(options)",
-   "page": "/lua/latest/guides/environment/",
-   "line": 44,
-   "why": "no port defines it"
-  },
-  {
-   "port": "lua",
-   "text": "D",
-   "page": "/lua/latest/guides/panes/",
-   "line": 78,
-   "why": "no port defines it"
-  },
-  {
-   "port": "lua",
-   "text": "H",
-   "page": "/lua/latest/guides/panes/",
-   "line": 78,
-   "why": "no port defines it"
-  },
-  {
-   "port": "lua",
-   "text": "O",
-   "page": "/lua/latest/guides/panes/",
-   "line": 78,
-   "why": "no port defines it"
-  },
-  {
-   "port": "lua",
-   "text": "P",
-   "page": "/lua/latest/guides/panes/",
-   "line": 78,
-   "why": "no port defines it"
-  },
-  {
-   "port": "lua",
-   "text": "W",
-   "page": "/lua/latest/guides/panes/",
-   "line": 78,
-   "why": "no port defines it"
-  },
-  {
-   "port": "lua",
-   "text": "X",
-   "page": "/lua/latest/guides/panes/",
-   "line": 78,
-   "why": "no port defines it"
+   "text": "err.partial.outcomes",
+   "page": "/lua/latest/guides/commands/",
+   "line": 47,
+   "why": "not defined in the stated port"
   },
   {
    "port": "lua",
-   "text": "list_options(options)",
-   "page": "/lua/latest/guides/settings/",
-   "line": 31,
-   "why": "no port defines it"
+   "text": "Since",
+   "page": "/lua/latest/guides/fields/",
+   "line": 33,
+   "why": "not defined in the stated port"
   },
   {
    "port": "lua",
    "text": "acquisition.started",
    "page": "/lua/latest/guides/snapshots/",
    "line": 76,
-   "why": "no port defines it"
+   "why": "not defined in the stated port"
   },
   {
    "port": "ruby",
    "text": "Enumerable",
    "page": "/ruby/latest/guides/overview/",
    "line": 14,
-   "why": "no port defines it"
+   "why": "not defined in the stated port"
+  },
+  {
+   "port": "ruby",
+   "text": "LibTmux",
+   "page": "/ruby/latest/guides/overview/",
+   "line": 116,
+   "why": "not defined in the stated port"
   },
   {
    "port": "ruby",
@@ -7665,146 +7427,62 @@
    "text": "libtmux._internal",
    "page": "/concepts/transports/",
    "line": 33,
-   "why": "no port defines it"
-  },
-  {
-   "port": "go",
-   "text": "OpenNotifications",
-   "page": "/concepts/transports/",
-   "line": 35,
-   "why": "no port defines it"
+   "why": "not defined in the stated port"
   },
   {
    "port": "swift",
    "text": "TmuxWorkspace",
    "page": "/concepts/workspaces/",
-   "line": 133,
-   "why": "no port defines it"
+   "line": 134,
+   "why": "not defined in the stated port"
   },
   {
    "port": "swift",
    "text": "YAMLWorkspaces",
    "page": "/concepts/workspaces/",
-   "line": 133,
-   "why": "no port defines it"
+   "line": 134,
+   "why": "not defined in the stated port"
   },
   {
    "port": "dotnet",
    "text": "ConnectAndBuild",
    "page": "/examples/attach-and-send-keys/",
    "line": 152,
-   "why": "no port defines it"
-  },
-  {
-   "port": "java",
-   "text": "WatchPaneOutput",
-   "page": "/examples/capture-pane-output/",
-   "line": 193,
-   "why": "no port defines it"
-  },
-  {
-   "port": "go",
-   "text": "Example()",
-   "page": "/examples/workspace-from-file/",
-   "line": 28,
-   "why": "no port defines it"
-  },
-  {
-   "port": "go",
-   "text": "Example",
-   "page": "/examples/workspace-from-file/",
-   "line": 28,
-   "why": "no port defines it"
+   "why": "not defined in the stated port"
   },
   {
    "port": "swift",
    "text": "YAMLWorkspaces",
    "page": "/examples/workspace-from-file/",
-   "line": 119,
-   "why": "no port defines it"
-  },
-  {
-   "port": "go",
-   "text": "Example()",
-   "page": "/examples/workspace-from-file/",
-   "line": 147,
-   "why": "no port defines it"
-  },
-  {
-   "port": "swift",
-   "text": "CreateSessionAsync",
-   "page": "/guides/attaching-to-tmux/",
-   "line": 158,
-   "why": "no port defines it"
-  },
-  {
-   "port": "swift",
-   "text": "ReplaceExisting",
-   "page": "/guides/attaching-to-tmux/",
-   "line": 159,
-   "why": "no port defines it"
-  },
-  {
-   "port": "swift",
-   "text": "<doc:Waiting>",
-   "page": "/guides/capturing-output/",
-   "line": 148,
-   "why": "no port defines it"
-  },
-  {
-   "port": "rs",
-   "text": "Display",
-   "page": "/guides/querying-and-filtering/",
-   "line": 21,
-   "why": "no port defines it"
+   "line": 120,
+   "why": "not defined in the stated port"
   },
   {
-   "port": "cxx",
+   "port": "dotnet",
    "text": "IEnumerable<T>.Matching<T>(expression)",
    "page": "/guides/querying-and-filtering/",
-   "line": 56,
-   "why": "no port defines it"
+   "line": 61,
+   "why": "not defined in the stated port"
   },
   {
    "port": "dotnet",
    "text": "src/LibTmux.Testing/",
    "page": "/guides/testing-with-libtmux/",
-   "line": 95,
-   "why": "no port defines it"
+   "line": 113,
+   "why": "not defined in the stated port"
   },
   {
    "port": "swift",
    "text": "TmuxFixture",
    "page": "/guides/testing-with-libtmux/",
-   "line": 132,
-   "why": "no port defines it"
-  },
-  {
-   "port": "go",
-   "text": "Example",
-   "page": "/go/latest/workspace/internals/examples/",
-   "line": 19,
+   "line": 150,
    "why": "not defined in the stated port"
   },
   {
    "port": "swift",
    "text": "YAMLWorkspaces",
-   "page": "/swift/latest/workspace/internals/examples/",
-   "line": 19,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "swift",
-   "text": "TmuxWorkspace",
    "page": "/swift/latest/workspace/internals/guides/",
-   "line": 13,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "swift",
-   "text": "TmuxFixture",
-   "page": "/swift/latest/workspace/internals/guides/",
-   "line": 14,
+   "line": 59,
    "why": "not defined in the stated port"
   },
   {
@@ -7835,27 +7513,6 @@
    "line": 13,
    "why": "not defined in the stated port"
   },
-  {
-   "port": "swift",
-   "text": "Sendable",
-   "page": "/swift/latest/workspace/reference/",
-   "line": 21,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "swift",
-   "text": "Hashable",
-   "page": "/swift/latest/workspace/reference/",
-   "line": 21,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "swift",
-   "text": "Codable",
-   "page": "/swift/latest/workspace/reference/",
-   "line": 21,
-   "why": "not defined in the stated port"
-  },
   {
    "port": "swift",
    "text": "YAMLWorkspaces",
@@ -7867,119 +7524,28 @@
    "port": "swift",
    "text": "YAMLWorkspaces",
    "page": "/swift/latest/workspace/reference/compatibility/",
-   "line": 71,
+   "line": 20,
    "why": "not defined in the stated port"
   },
   {
    "port": "swift",
    "text": "TmuxWorkspace",
    "page": "/swift/latest/workspace/reference/compatibility/",
-   "line": 150,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "swift",
-   "text": "YAMLWorkspaces",
-   "page": "/swift/latest/workspace/reference/compatibility/",
-   "line": 151,
+   "line": 33,
    "why": "not defined in the stated port"
   },
-  {
-   "port": "cxx",
-   "text": "Sendable",
-   "page": "/topics/architecture/",
-   "line": 63,
-   "why": "no port defines it"
-  },
-  {
-   "port": "dotnet",
-   "text": "OwnedPaneScope",
-   "page": "/topics/context-managers/",
-   "line": 66,
-   "why": "no port defines it"
-  },
-  {
-   "port": "ts",
-   "text": "defer conn.Close()",
-   "page": "/topics/context-managers/",
-   "line": 154,
-   "why": "no port defines it"
-  },
   {
    "port": "ts",
-   "text": "Kill(ctx)",
+   "text": "[Symbol.asyncDispose]",
    "page": "/topics/context-managers/",
-   "line": 155,
-   "why": "no port defines it"
+   "line": 147,
+   "why": "not defined in the stated port"
   },
   {
    "port": "swift",
    "text": "throws(TmuxError)",
    "page": "/topics/errors-and-exceptions/",
-   "line": 30,
-   "why": "no port defines it"
-  },
-  {
-   "port": "rs",
-   "text": "TimedOut",
-   "page": "/topics/errors-and-exceptions/",
-   "line": 69,
-   "why": "no port defines it"
-  },
-  {
-   "port": "rs",
-   "text": "BTreeMap",
-   "page": "/topics/options-and-hooks/",
-   "line": 56,
-   "why": "no port defines it"
-  },
-  {
-   "port": "dotnet",
-   "text": "Literal",
-   "page": "/topics/pane-interaction/",
-   "line": 74,
-   "why": "no port defines it"
-  },
-  {
-   "port": "rs",
-   "text": "TimedOut",
-   "page": "/topics/waiting-and-retry/",
-   "line": 145,
-   "why": "no port defines it"
-  },
-  {
-   "port": "swift",
-   "text": "TmuxWorkspace",
-   "page": "/swift/latest/workspace/configuration/",
-   "line": 97,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "swift",
-   "text": "YAMLWorkspaces",
-   "page": "/swift/latest/workspace/configuration/",
-   "line": 98,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "dotnet",
-   "text": "LibTmux.Workspace.Cli",
-   "page": "/dotnet/latest/workspace/guides/installation/",
-   "line": 7,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "dotnet",
-   "text": "~/.dotnet/tools",
-   "page": "/dotnet/latest/workspace/guides/installation/",
-   "line": 28,
-   "why": "not defined in the stated port"
-  },
-  {
-   "port": "swift",
-   "text": "TmuxWorkspace",
-   "page": "/swift/latest/workspace/",
-   "line": 79,
+   "line": 31,
    "why": "not defined in the stated port"
   }
  ]
diff --git a/site/src/data/port-guides/kotlin.json b/site/src/data/port-guides/kotlin.json
index c3b3722a..82a4a4de 100644
--- a/site/src/data/port-guides/kotlin.json
+++ b/site/src/data/port-guides/kotlin.json
@@ -1,16 +1,16 @@
 {
   "source": {
     "repository": "libtmux/libtmux-java",
-    "revision": "49c83f633c6d6425ba93c0c30af0bd91a3910364"
+    "revision": "3c9ad0ee5698554b9311b3fbc63d3e33873830c6"
   },
   "guides": [
     {
       "path": "libtmux-kotlin/README.md",
-      "content": "# libtmux-kotlin\n\n**Coroutine wrapper classes, a session/window/split DSL, and `Flow`/`StateFlow`\nbridges over the Java API.**\n\n`io.github.libtmux:libtmux-kotlin` — [on Maven Central](https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin).\n\n> **Alpha.** The API will change without notice.\n\nNeeds Kotlin 2.1 or later. The module is compiled for Kotlin 2.2 metadata and\nthe 2.2 standard library, the level kotlinx-coroutines 1.11 is compiled for, and\na Kotlin compiler reads metadata up to one minor version newer than itself.\n`ConsumerBaselineTest` fails if a build raises that level.\n\nEvery Kotlin example below is executed against a real tmux server by\n[`ReadmeExamplesTest`](src/test/kotlin/io/github/libtmux/kotlin/ReadmeExamplesTest.kt),\none test per section.\n\n## Install\n\n<!-- snippet: skip: build configuration, not library code -->\n```kotlin\ndependencies {\n    implementation(platform(\"io.github.libtmux:libtmux-bom:0.0.1-alpha.17\"))\n    implementation(\"io.github.libtmux:libtmux-kotlin\")\n}\n```\n\n## Wrapper classes, not the Java types directly\n\n`Server`, `Session`, `Window`, `Pane`, `Client`, and `ControlClient` here are\nKotlin classes over the matching Java handle, which each answers as `asJava`;\n`Server.fromJava` wraps a server opened in Java. Every operation that reaches\ntmux is `suspend`; captured state is a plain property. A tmux subsystem an\naccessor answers — `Pane.options()`, `Server.hooks()`, `Server.keys()`, and\nthe rest — is wrapped the same way, so calling into it never blocks the\ncaller's thread outside `ExecutionPolicy`.\n`withServer` opens one and closes it even if the block throws or is\ncancelled:\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val session = server.newSession(\"build\")\n\n    session.name                          // → build\n    server.admissionBound > 0             // → true\n}\n```\n\n## Declare a session, its windows, and their splits with the DSL\n\n`@DslMarker` keeps a nested block from reaching an outer block's receiver by\naccident: a `split { }` inside a `window { }` cannot set the *session's*\n`directory` without writing `this@newSession.directory` to say so. tmux\nalways gives a new session one window; the first `window { }` block renames\nthat one, and each later block is a genuine new window — two blocks make two\nwindows, not three.\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val session = server.newSession {\n        name = \"editors\"\n        window { name = \"left\" }\n        window {\n            name = \"right\"\n            split { toRight(); percent(30) }\n        }\n    }\n\n    session.windows.size                  // → 2\n}\n```\n\n## Send keys, capture output, run a command\n\n```kotlin\n// Given: config: ServerConfig\nimport io.github.libtmux.kotlin.orNull\nimport kotlin.time.Duration.Companion.seconds\n\nwithServer(config) { server ->\n    val session = server.newSession(\"keys-demo\")\n    val pane = session.activeWindow?.activePane ?: error(\"no active pane\")\n\n    pane.sendLine(\"echo ready\")\n    pane.awaitText(\"ready\", timeout = 5.seconds)\n    val lines = pane.capture()\n\n    val run = pane.run(\"echo hi && exit 3\", timeout = 5.seconds)\n    run.exitStatus.orNull()                // → 3\n    lines.isNotEmpty()                    // → true\n}\n```\n\n## Query with typed fields on the companion\n\nFields live on the handle type's companion — `Pane.command`, not a static\n`Pane_.command()` — generated from the same `field-catalog.tsv` that\ngenerates the Java metamodel, so the two can never disagree.\n\n```kotlin\n// Given: config: ServerConfig\nimport io.github.libtmux.kotlin.query.active\nimport io.github.libtmux.kotlin.query.command\n\nwithServer(config) { server ->\n    server.newSession(\"query-demo\")\n    val editors = server.panes(Pane.command startsWith \"nvim\")\n    val activePanes = server.panes(Pane.active.isTrue())\n\n    editors.size >= 0                     // → true\n    activePanes.isNotEmpty()              // → true\n}\n```\n\n`server.session(expr)` throws `CardinalityException` on no match or more than\none; `server.sessionOrNull(expr)` is null on no match and still throws on\nmore than one — Kotlin's own collection convention (`single`/`singleOrNull`),\napplied to a tmux lookup.\n\n## Exhaustive `when` over the sealed failure tree\n\n```kotlin\nimport io.github.libtmux.exception.CardinalityException\nimport io.github.libtmux.exception.CommandRejectedException\nimport io.github.libtmux.exception.ControlEndedException\nimport io.github.libtmux.exception.DispatchException\nimport io.github.libtmux.exception.LibTmuxException\nimport io.github.libtmux.exception.MalformedResponseException\nimport io.github.libtmux.exception.ServerUnavailableException\nimport io.github.libtmux.exception.TargetGoneException\nimport io.github.libtmux.exception.UnencodableTextException\nimport io.github.libtmux.exception.UnsupportedFeatureException\n\nfun nextStep(failure: LibTmuxException): String =\n    when (failure) {                                // exhaustive, no else\n        is TargetGoneException -> \"look it up again\"\n        is ServerUnavailableException -> \"start a server\"\n        is CommandRejectedException -> \"change the request\"\n        is DispatchException -> if (failure.safeToRetry()) \"send it again\" else \"read state first\"\n        is ControlEndedException -> \"attach again\"\n        is UnsupportedFeatureException -> \"do without\"\n        is UnencodableTextException -> \"use a UTF-8 locale\"\n        is MalformedResponseException -> \"report it\"\n        is CardinalityException.NoMatch -> \"nothing matched\"\n        is CardinalityException.MultipleMatches -> \"ambiguous\"\n    }\n\nnextStep(CardinalityException.MultipleMatches(\"many\", 3))   // → ambiguous\n```\n\nA new leaf breaks every such `when` at the branch that omits it:\n`ExhaustivenessCompileTest` compiles a `when` one branch short and asserts the\ncompiler rejects it.\n\n## A subscription as a cold `Flow`\n\n```kotlin\n// Given: config: ServerConfig\nimport io.github.libtmux.control.Delivery\nimport kotlinx.coroutines.flow.first\n\nwithServer(config) { server ->\n    val session = server.newSession(\"flow-demo\")\n    withControl(server, session) { control ->\n        val step = control.output(capacity = 64) {\n            control.send(\"send-keys\", \"-t\", session.name, \"echo flowed\", \"Enter\")\n        }.first()\n        val outcome = when (step) {            // exhaustive, no else\n            is Delivery.Event -> \"kept\"\n            is Delivery.Gap -> \"lost ${step.missed}\"\n        }\n        outcome                                // → kept\n    }\n}\n```\n\n`output`/`events` open a *fresh* Java subscription per `collect()` — over\n`EventSubscription.poll`/`onReady`, never a parked thread — and close it when\ncollection ends, is cancelled, or throws. Output tmux sends before that\nsubscription opens is not delivered, so the command whose output you want goes\nin the trailing `onSubscribed` block, which runs once the subscription exists\nand before the first read. A `Delivery.Gap` is an element like any other,\nahead of the events that survived a full buffer; nothing is silently dropped.\n\n## The live server as a `StateFlow`\n\n```kotlin\n// Given: config: ServerConfig\nimport kotlinx.coroutines.flow.first\n\nwithServer(config) { server ->\n    val session = server.newSession(\"live-demo\")\n    server.withLiveState(session) { live ->\n        val view = live.first()\n\n        view.epoch >= 0L                  // → true\n    }\n}\n```\n\nWraps Java's `ServerMirror` — resnapshot on notification, on gap, and on\nreconnect happen once, inside it — rather than patching state in Kotlin.\nNamed `liveState`, not `ServerMirror`, so it does not collide with the Java\ntype it wraps. `liveState`'s own background pump runs until its scope ends,\nby design — a caller collecting for a program's whole life passes its own\nlong-lived scope — so `withLiveState` is the scoped form for everything\nshorter: it cancels the pump once its block returns, the same shape\n`withServer`/`withControl` already have for the resources they open.\n\n## Retry using the safe-to-retry predicate\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val version = retryIfSafe(times = 3) { server.version() }\n    version.major >= 3                    // → true\n}\n```\n\n`retryIfSafe` catches only `DispatchException` and checks\n`failure.safeToRetry()`, computed by the operation that threw it from its own\ncatalogued idempotence — no retry executor, and no catalog lookup at the call\nsite.\n\n## Why nothing in Java may depend on this\n\nThe build fails if it does. Per the JSpecify specification a class carrying\n`@kotlin.Metadata` is **not** null-marked, because the Kotlin compiler does not\nyet emit full nullness into binaries\n([KT-47417](https://youtrack.jetbrains.com/projects/KT/issues/KT-47417/Emit-jspecify-annotations-for-types-in-Kotlin-binaries)).\nA Kotlin-authored API would therefore be worse for a Java caller and invisible to\nNullAway. The dependency runs one way only.\n\n## Next\n\n- [Kotlin guide](../docs/guide/kotlin.md)\n- [`libtmux`](../libtmux/) — the API this wraps\n- [Root README](../README.md)\n"
+      "content": "<!-- libtmux-logo -->\n<p align=\"center\">\n  <picture>\n    <source srcset=\"assets/logo.svg\" type=\"image/svg+xml\">\n    <img src=\"assets/logo.png\" width=\"128\" height=\"128\" alt=\"libtmux for Kotlin\">\n  </picture>\n</p>\n<!-- /libtmux-logo -->\n\n<div align=\"center\">\n\n# libtmux-kotlin\n\n**Coroutine wrapper classes, a session/window/split DSL, and `Flow`/`StateFlow`\nbridges over the Java API.**\n\n</div>\n\n`io.github.libtmux:libtmux-kotlin` — [on Maven Central](https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin).\n\n> **Alpha.** The API will change without notice.\n\nNeeds Kotlin 2.1 or later. The module is compiled for Kotlin 2.2 metadata and\nthe 2.2 standard library, the level kotlinx-coroutines 1.11 is compiled for, and\na Kotlin compiler reads metadata up to one minor version newer than itself.\n`ConsumerBaselineTest` fails if a build raises that level.\n\nThe [documentation tests](../docs/README.md#kotlin-fences) compile and run\nthe Kotlin examples against a real tmux server.\n\n## Install\n\nUse JDK 25 or newer, tmux 3.2a through 3.7c, and a Gradle Kotlin/JVM\nproject with its Gradle wrapper. Name the project in `settings.gradle.kts`:\n\n<!-- snippet: skip: Gradle project settings -->\n```kotlin\nrootProject.name = \"tmux-demo\"\n```\n\nSave this as `build.gradle.kts`:\n\n<!-- snippet: skip: Gradle build configuration, checked by the consumer build -->\n```kotlin\nplugins {\n    kotlin(\"jvm\") version \"2.4.10\"\n    application\n}\n\nrepositories { mavenCentral() }\n\nkotlin { jvmToolchain(25) }\n\ndependencies {\n    implementation(platform(\"io.github.libtmux:libtmux-bom:0.0.1-alpha.17\"))\n    implementation(\"io.github.libtmux:libtmux-kotlin\")\n}\n\napplication { mainClass = \"MainKt\" }\n```\n\n## Create and clean up a private session\n\nSave this complete program as `src/main/kotlin/Main.kt`. It creates a fresh\nsocket directory under `/tmp/libtmux-java-dev/`, starts its own tmux server,\nprints the created session's name, and removes that server before closing the\nclient. It reads tmux from `PATH`; set `LIBTMUX_TMUX` to select another binary.\n\n<!-- snippet: main -->\n```kotlin\nimport io.github.libtmux.ServerConfig\nimport io.github.libtmux.ServerEndpoint\nimport io.github.libtmux.kotlin.*\nimport java.nio.file.Files\nimport java.nio.file.Path\nimport kotlinx.coroutines.runBlocking\n\nfun main() = runBlocking {\n    val root = Files.createDirectories(Path.of(\"/tmp/libtmux-java-dev\"))\n    val directory = Files.createTempDirectory(root, \"kotlin-start-\")\n    val socket = directory.resolve(\"s\")\n    val config = ServerConfig.builder()\n        .binary(System.getenv(\"LIBTMUX_TMUX\") ?: \"tmux\")\n        .endpoint(ServerEndpoint.socketPath(socket))\n        .configFile(Path.of(\"/dev/null\"))\n        .build()\n    try {\n        withServer(config) { server ->\n            try {\n                val session = server.newSession(\"kotlin-start\")\n                check(session.name == \"kotlin-start\")\n                println(session.name)\n            } finally {\n                server.killServer()\n            }\n        }\n    } finally {\n        Files.deleteIfExists(socket)\n        Files.deleteIfExists(directory)\n    }\n}\n```\n\nRun the application:\n\n```console\n$ ./gradlew run\n```\n\nThe output includes `kotlin-start`. `withServer` closes the library client;\nit does not stop tmux. This program calls `killServer` because it owns the\nprivate daemon. When connecting to an existing daemon, leave its lifetime\nwith its owner and remove only sessions your application created.\n\nLater examples declare the `config` they expect. Supply the configuration\nabove and retain its private-server cleanup when trying those calls.\n\n## Wrapper classes, not the Java types directly\n\n`Server`, `Session`, `Window`, `Pane`, `Client`, and `ControlClient` here are\nKotlin classes over the matching Java handle, which each answers as `asJava`;\n`Server.fromJava` wraps a server opened in Java. Every operation that reaches\ntmux is `suspend`; captured state is a plain property. A tmux subsystem an\naccessor answers — `Pane.options()`, `Server.hooks()`, `Server.keys()`, and\nthe rest — is wrapped the same way, so calling into it never blocks the\ncaller's thread outside `ExecutionPolicy`.\n`withServer` opens one and closes it even if the block throws or is\ncancelled:\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val session = server.newSession(\"build\")\n\n    session.name                          // → build\n    server.admissionBound > 0             // → true\n}\n```\n\n## Declare a session, its windows, and their splits with the DSL\n\n`@DslMarker` keeps a nested block from reaching an outer block's receiver by\naccident: a `split { }` inside a `window { }` cannot set the *session's*\n`directory` without writing `this@newSession.directory` to say so. tmux\nalways gives a new session one window; the first `window { }` block renames\nthat one, and each later block is a genuine new window — two blocks make two\nwindows, not three.\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val session = server.newSession {\n        name = \"editors\"\n        window { name = \"left\" }\n        window {\n            name = \"right\"\n            split { toRight(); percent(30) }\n        }\n    }\n\n    session.windows.size                  // → 2\n}\n```\n\n## Send keys, capture output, run a command\n\n```kotlin\n// Given: config: ServerConfig\nimport io.github.libtmux.kotlin.orNull\nimport kotlin.time.Duration.Companion.seconds\n\nwithServer(config) { server ->\n    val session = server.newSession(\"keys-demo\")\n    val pane = session.activeWindow?.activePane ?: error(\"no active pane\")\n\n    pane.sendLine(\"echo ready\")\n    pane.awaitText(\"ready\", timeout = 5.seconds)\n    val lines = pane.capture()\n\n    val run = pane.run(\"echo hi && exit 3\", timeout = 5.seconds)\n    run.exitStatus.orNull()                // → 3\n    lines.isNotEmpty()                    // → true\n}\n```\n\n## Query with typed fields on the companion\n\nFields live on the handle type's companion — `Pane.command`, not a static\n`Pane_.command()` — generated from the same `field-catalog.tsv` that\ngenerates the Java metamodel, so the two can never disagree.\n\n```kotlin\n// Given: config: ServerConfig\nimport io.github.libtmux.kotlin.query.active\nimport io.github.libtmux.kotlin.query.command\n\nwithServer(config) { server ->\n    server.newSession(\"query-demo\")\n    val editors = server.panes(Pane.command startsWith \"nvim\")\n    val activePanes = server.panes(Pane.active.isTrue())\n\n    editors.size >= 0                     // → true\n    activePanes.isNotEmpty()              // → true\n}\n```\n\n`server.session(expr)` throws `CardinalityException` on no match or more than\none; `server.sessionOrNull(expr)` is null on no match and still throws on\nmore than one — Kotlin's own collection convention (`single`/`singleOrNull`),\napplied to a tmux lookup.\n\n## Exhaustive `when` over the sealed failure tree\n\n```kotlin\nimport io.github.libtmux.exception.CardinalityException\nimport io.github.libtmux.exception.CommandRejectedException\nimport io.github.libtmux.exception.ControlEndedException\nimport io.github.libtmux.exception.DispatchException\nimport io.github.libtmux.exception.LibTmuxException\nimport io.github.libtmux.exception.MalformedResponseException\nimport io.github.libtmux.exception.ServerUnavailableException\nimport io.github.libtmux.exception.TargetGoneException\nimport io.github.libtmux.exception.UnencodableTextException\nimport io.github.libtmux.exception.UnsupportedFeatureException\n\nfun nextStep(failure: LibTmuxException): String =\n    when (failure) {                                // exhaustive, no else\n        is TargetGoneException -> \"look it up again\"\n        is ServerUnavailableException -> \"start a server\"\n        is CommandRejectedException -> \"change the request\"\n        is DispatchException -> if (failure.safeToRetry()) \"send it again\" else \"read state first\"\n        is ControlEndedException -> \"attach again\"\n        is UnsupportedFeatureException -> \"do without\"\n        is UnencodableTextException -> \"use a UTF-8 locale\"\n        is MalformedResponseException -> \"report it\"\n        is CardinalityException.NoMatch -> \"nothing matched\"\n        is CardinalityException.MultipleMatches -> \"ambiguous\"\n    }\n\nnextStep(CardinalityException.MultipleMatches(\"many\", 3))   // → ambiguous\n```\n\nA new leaf breaks every such `when` at the branch that omits it:\n`ExhaustivenessCompileTest` compiles a `when` one branch short and asserts the\ncompiler rejects it.\n\n## A subscription as a cold `Flow`\n\n```kotlin\n// Given: config: ServerConfig\nimport io.github.libtmux.control.Delivery\nimport kotlinx.coroutines.flow.first\n\nwithServer(config) { server ->\n    val session = server.newSession(\"flow-demo\")\n    withControl(server, session) { control ->\n        val step = control.output(capacity = 64) {\n            control.send(\"send-keys\", \"-t\", session.name, \"echo flowed\", \"Enter\")\n        }.first()\n        val outcome = when (step) {            // exhaustive, no else\n            is Delivery.Event -> \"kept\"\n            is Delivery.Gap -> \"lost ${step.missed}\"\n        }\n        outcome                                // → kept\n    }\n}\n```\n\n`output`/`events` open a *fresh* Java subscription per `collect()` — over\n`EventSubscription.poll`/`onReady`, never a parked thread — and close it when\ncollection ends, is cancelled, or throws. Output tmux sends before that\nsubscription opens is not delivered, so the command whose output you want goes\nin the trailing `onSubscribed` block, which runs once the subscription exists\nand before the first read. A `Delivery.Gap` is an element like any other,\nahead of the events that survived a full buffer; nothing is silently dropped.\n\n## The live server as a `StateFlow`\n\n```kotlin\n// Given: config: ServerConfig\nimport kotlinx.coroutines.flow.first\n\nwithServer(config) { server ->\n    val session = server.newSession(\"live-demo\")\n    server.withLiveState(session) { live ->\n        val view = live.first()\n\n        view.epoch >= 0L                  // → true\n    }\n}\n```\n\nWraps Java's `ServerMirror` — resnapshot on notification, on gap, and on\nreconnect happen once, inside it — rather than patching state in Kotlin.\nNamed `liveState`, not `ServerMirror`, so it does not collide with the Java\ntype it wraps. `liveState`'s own background pump runs until its scope ends,\nby design — a caller collecting for a program's whole life passes its own\nlong-lived scope — so `withLiveState` is the scoped form for everything\nshorter: it cancels the pump once its block returns, the same shape\n`withServer`/`withControl` already have for the resources they open.\n\n## Retry using the safe-to-retry predicate\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val version = retryIfSafe(times = 3) { server.version() }\n    version.major >= 3                    // → true\n}\n```\n\n`retryIfSafe` catches only `DispatchException` and checks\n`failure.safeToRetry()`, computed by the operation that threw it from its own\ncatalogued idempotence — no retry executor, and no catalog lookup at the call\nsite.\n\n## Why nothing in Java may depend on this\n\nThe build fails if it does. Per the JSpecify specification a class carrying\n`@kotlin.Metadata` is **not** null-marked, because the Kotlin compiler does not\nyet emit full nullness into binaries\n([KT-47417](https://youtrack.jetbrains.com/projects/KT/issues/KT-47417/Emit-jspecify-annotations-for-types-in-Kotlin-binaries)).\nA Kotlin-authored API would therefore be worse for a Java caller and invisible to\nNullAway. The dependency runs one way only.\n\n## Next\n\n- [Kotlin guide](../docs/guide/kotlin.md)\n- [`libtmux`](../libtmux/) — the API this wraps\n- [Root README](../README.md)\n"
     },
     {
       "path": "docs/guide/kotlin.md",
-      "content": "# Kotlin\n\n## Wrapper classes over the Java handles\n\n`Server`, `Session`, `Window`, `Pane`, `Client`, and `ControlClient` in\n`io.github.libtmux.kotlin` are hand-written Kotlin classes, not the Java types\ndirectly and not extensions on them. A same-named extension is silently\nshadowed by a Java member with only a compiler warning, so a member on a real\nwrapper class is what makes a generated suspend mirror safe to add later\nwithout an accidental collision.\n\nEvery operation that may contact tmux is `suspend`. Captured state — an id, a\nname, a size — is a plain, non-suspending property. Query fields live on the\nhandle type's companion (`Pane.command`), never as an instance member, so\n`Pane.command` (the field) and `pane.currentCommand` (the captured value)\nnever collide.\n\nA tmux subsystem an accessor answers — `Pane.options()`, `Server.hooks()`,\n`Server.shell()`, `Server.commands()`, `Server.buffers()`,\n`Session.environment()`, `Server.messageLog()`, `Server.prompt()`,\n`Server.keys()`, `Server.batch()`, `Server.chain()` — is wrapped the same way:\na small Kotlin class over the Java handle, whose own operations are `suspend`\nin turn.\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val session = server.newSession(\"guide-demo\")\n\n    session.name                          // → guide-demo\n}\n```\n\nEach wrapper answers the Java handle it holds as `asJava`, the same object\nrather than a copy, for a Java API that takes one. `Server.fromJava` goes the\nother way, over a server opened in Java, such as a test fixture's; closing the\nwrapper closes that server. The two sets of classes share simple names, so a\nfile that needs both imports one under an alias:\n`import io.github.libtmux.Server as JavaServer`.\n\n## `ExecutionPolicy`: two independently sized pools\n\n`ExecutionPolicy.commands` backs every `suspend` operation this module\ngenerates or hand-writes, sized from `ServerConfig.maxConcurrentCommands()` —\nthe transport's real admission bound, not a guessed constant.\n`ExecutionPolicy.streamReads` backs only what still genuinely blocks a\nthread: `Server.liveState`'s background pump. `ControlClient.output`/`events`\nhold no thread from either pool; they are built on the non-blocking\n`EventSubscription.poll`/`onReady` path, not a parked `next()`.\n\n`ExecutionPolicy.default(config)` sizes both pools; pass a differently-sized\none to `Server.open` or `withServer` when a program opens more than the\ndefault 16 concurrent `liveState` watches.\n\n## The cold `Flow` bridge, and why it is not `callbackFlow`\n\n`ControlClient.output`/`events` return a plain `flow {}` that calls\n`EventSubscription.poll()` from the collector itself, suspending on the\nsubscription's one-shot `onReady` callback via `suspendCancellableCoroutine`\nwhen nothing is buffered, and `clearReady()` on cancellation. A fresh Java\nsubscription opens per `collect()`, so two concurrent collections never share\none subscription's buffer or gap accounting.\n\nA `callbackFlow` over the same subscription would have its readiness callback\ndrain `poll()` straight into the flow's channel, where a full channel's\n`trySend` failing discards the polled item with no `Gap` recorded. `flow {}`\ncalls `poll()` only from the collector itself, so an overflow can only happen\ninside the subscription's own buffer, which is exactly what turns into a\n`Gap`.\n\n## Blocking calls from a coroutine\n\nEvery libtmux call blocks its thread until tmux answers. This module already\nwraps each one in `runInterruptible`, dispatched on `ExecutionPolicy.commands`\nor `.streamReads`, so cancelling the coroutine interrupts the wait rather than\nleaving it running past the point nothing is listening for its result.\n\n- An ordinary suspend call — `newSession`, `capture`, `sendLine` — already\n  runs on `policy.commands`, sized from the server's own admission bound.\n- `Server.liveState`'s background pump runs on `policy.streamReads`.\n- `ControlClient.output`/`events` hold no thread at all; only collecting the\n  returned `Flow` reads.\n\n## The DSL, and the compile error the first draft had\n\n`@DslMarker` marks `SessionBuilder`, `WindowBuilder`, and `SplitBuilder` so an\ninner block cannot reach an outer block's receiver by accident. Directory is\nsettable at all three levels for exactly this reason: writing `directory = x`\ninside a nested `split { }` resolves to the innermost builder, and reaching\nthe outer one on purpose needs `this@newSession.directory = x` written out.\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val session = server.newSession {\n        name = \"layout-demo\"\n        window { name = \"editor\" }\n        window {\n            name = \"shell\"\n            split { toRight(); percent(30) }\n        }\n    }\n\n    session.windows.size                  // → 2\n}\n```\n\ntmux's `SplitSpec.Builder` spells direction and size as method calls —\n`below()`/`above()`/`toRight()`/`toLeft()`, `cells(n)`/`percent(n)` — not an\nenum. The DSL forwards to that real vocabulary directly rather than inventing\na parallel `SplitDirection`/`PaneSize` type.\n\n`env(name, value)` is on `SessionBuilder`, `WindowBuilder`, and `SplitBuilder`\nalike, matching the Java `SessionSpec.Builder`/`WindowSpec.Builder`/\n`SplitSpec.Builder` each has, and sets a variable in the environment the new\nsession, window, or pane's process starts with.\n\n## Why nothing in Java may depend on this\n\nNothing written in Java may depend on `libtmux-kotlin`, and the build fails if\nit does. Per the JSpecify specification a class carrying `@kotlin.Metadata` is\n*not* null-marked, because the Kotlin compiler does not yet emit full\nnullness into binaries\n([KT-47417](https://youtrack.jetbrains.com/projects/KT/issues/KT-47417/Emit-jspecify-annotations-for-types-in-Kotlin-binaries)).\nA Kotlin-authored API would therefore be worse for a Java caller and invisible\nto NullAway. The dependency runs one way only.\n\nSee the [module README](../../libtmux-kotlin/README.md) for the full call-site\ntour, including the query DSL, the exhaustive `when` over sealed failures, and\n`StateFlow`.\n"
+      "content": "# Kotlin\n\nStart with the [complete program](../../libtmux-kotlin/README.md#create-and-clean-up-a-private-session)\nfor configuration and cleanup. This guide explains coroutine behavior and DSL\nscopes when using those same handles.\n\n## Wrapper classes over the Java handles\n\n`Server`, `Session`, `Window`, `Pane`, `Client`, and `ControlClient` in\n`io.github.libtmux.kotlin` are hand-written Kotlin classes, not the Java types\ndirectly and not extensions on them. A same-named extension is silently\nshadowed by a Java member with only a compiler warning, so a member on a real\nwrapper class is what makes a generated suspend mirror safe to add later\nwithout an accidental collision.\n\nEvery operation that may contact tmux is `suspend`. Captured state — an id, a\nname, a size — is a plain, non-suspending property. Query fields live on the\nhandle type's companion (`Pane.command`), never as an instance member, so\n`Pane.command` (the field) and `pane.currentCommand` (the captured value)\nnever collide.\n\nA tmux subsystem an accessor answers — `Pane.options()`, `Server.hooks()`,\n`Server.shell()`, `Server.commands()`, `Server.buffers()`,\n`Session.environment()`, `Server.messageLog()`, `Server.prompt()`,\n`Server.keys()`, `Server.batch()`, `Server.chain()` — is wrapped the same way:\na small Kotlin class over the Java handle, whose own operations are `suspend`\nin turn.\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val session = server.newSession(\"guide-demo\")\n\n    session.name                          // → guide-demo\n}\n```\n\nEach wrapper answers the Java handle it holds as `asJava`, the same object\nrather than a copy, for a Java API that takes one. `Server.fromJava` goes the\nother way, over a server opened in Java, such as a test fixture's; closing the\nwrapper closes that server. The two sets of classes share simple names, so a\nfile that needs both imports one under an alias:\n`import io.github.libtmux.Server as JavaServer`.\n\n## `ExecutionPolicy`: two independently sized pools\n\n`ExecutionPolicy.commands` backs every `suspend` operation this module\ngenerates or hand-writes, sized from `ServerConfig.maxConcurrentCommands()` —\nthe transport's real admission bound, not a guessed constant.\n`ExecutionPolicy.streamReads` backs only what still genuinely blocks a\nthread: `Server.liveState`'s background pump. `ControlClient.output`/`events`\nhold no thread from either pool; they are built on the non-blocking\n`EventSubscription.poll`/`onReady` path, not a parked `next()`.\n\n`ExecutionPolicy.default(config)` sizes both pools; pass a differently-sized\none to `Server.open` or `withServer` when a program opens more than the\ndefault 16 concurrent `liveState` watches.\n\n## The cold `Flow` bridge, and why it is not `callbackFlow`\n\n`ControlClient.output`/`events` return a plain `flow {}` that calls\n`EventSubscription.poll()` from the collector itself, suspending on the\nsubscription's one-shot `onReady` callback via `suspendCancellableCoroutine`\nwhen nothing is buffered, and `clearReady()` on cancellation. A fresh Java\nsubscription opens per `collect()`, so two concurrent collections never share\none subscription's buffer or gap accounting.\n\nA `callbackFlow` over the same subscription would have its readiness callback\ndrain `poll()` straight into the flow's channel, where a full channel's\n`trySend` failing discards the polled item with no `Gap` recorded. `flow {}`\ncalls `poll()` only from the collector itself, so an overflow can only happen\ninside the subscription's own buffer, which is exactly what turns into a\n`Gap`.\n\n## Blocking calls from a coroutine\n\nEvery libtmux call blocks its thread until tmux answers. This module already\nwraps each one in `runInterruptible`, dispatched on `ExecutionPolicy.commands`\nor `.streamReads`, so cancelling the coroutine interrupts the wait rather than\nleaving it running past the point nothing is listening for its result.\n\n- An ordinary suspend call — `newSession`, `capture`, `sendLine` — already\n  runs on `policy.commands`, sized from the server's own admission bound.\n- `Server.liveState`'s background pump runs on `policy.streamReads`.\n- `ControlClient.output`/`events` hold no thread at all; only collecting the\n  returned `Flow` reads.\n\n<a id=\"the-dsl-and-the-compile-error-the-first-draft-had\"></a>\n\n## Scope nested session builders\n\n`@DslMarker` marks `SessionBuilder`, `WindowBuilder`, and `SplitBuilder` so an\ninner block cannot reach an outer block's receiver by accident. Directory is\nsettable at all three levels for exactly this reason: writing `directory = x`\ninside a nested `split { }` resolves to the innermost builder, and reaching\nthe outer one on purpose needs `this@newSession.directory = x` written out.\n\n```kotlin\n// Given: config: ServerConfig\nwithServer(config) { server ->\n    val session = server.newSession {\n        name = \"layout-demo\"\n        window { name = \"editor\" }\n        window {\n            name = \"shell\"\n            split { toRight(); percent(30) }\n        }\n    }\n\n    session.windows.size                  // → 2\n}\n```\n\nUse `below()`/`above()`/`toRight()`/`toLeft()` to choose split direction and\n`cells(n)`/`percent(n)` to choose its size.\n\n`env(name, value)` is on `SessionBuilder`, `WindowBuilder`, and `SplitBuilder`\nalike, matching the Java `SessionSpec.Builder`/`WindowSpec.Builder`/\n`SplitSpec.Builder` each has, and sets a variable in the environment the new\nsession, window, or pane's process starts with.\n\nSee the [module README](../../libtmux-kotlin/README.md) for the full call-site\ntour, including the query DSL, the exhaustive `when` over sealed failures, and\n`StateFlow`.\n"
     }
   ]
 }
diff --git a/site/src/data/port-guides/lua.json b/site/src/data/port-guides/lua.json
new file mode 100644
index 00000000..694a649a
--- /dev/null
+++ b/site/src/data/port-guides/lua.json
@@ -0,0 +1,72 @@
+{
+  "source": {
+    "repository": "libtmux/libtmux-lua",
+    "revision": "777d546f87f9f5293e51f498d2addc7877b7561e"
+  },
+  "guides": [
+    {
+      "path": "README.md",
+      "content": "# libtmux for Lua\n\nScript tmux from Lua: create sessions and panes, capture terminal output,\nquery server state, and watch pane output. Use standalone Lua with luv or\nNeovim's event loop.\n\n**Alpha software.** The core API is still changing. The separate MCP and\nworkspace packages are unpublished scaffolds.\n\n[Install](#install) · [Read a server](#read-a-server) ·\n[Query](#query-captured-state) · [Create panes](#create-sessions-and-panes) ·\n[Neovim](#neovim) · [Guides](#guides) ·\n[CI](https://github.com/libtmux/libtmux-lua/actions/workflows/ci.yml) ·\n[MIT license](LICENSE)\n\n## Install\n\nInstall the core alpha with LuaRocks configured for your Lua interpreter:\n\n```console\n$ luarocks --local install libtmux 0.1.0alpha1-1\n```\n\nTo install from a checkout:\n\n```console\n$ luarocks --local make rockspecs/libtmux-scm-1.rockspec\n```\n\nSee the [changelog](CHANGES.md) and\n[release instructions](.github/CONTRIBUTING.md#releases) for release history\nand verification. Linux is tested; macOS remains unverified.\n\nAdd the local rocks tree to Lua's module paths:\n\n```console\n$ eval \"$(luarocks --local path)\"\n```\n\nFor standalone scripts, also install luv. Building it requires a C compiler\nand CMake. Neovim provides its own libuv binding.\n\n```console\n$ luarocks --local install luv 1.52.1-0\n```\n\nCore and local queries require only Lua. Importing a module does not start\ntmux or an event loop. CI runs unit tests on Lua 5.1–5.5 and LuaJIT, plus live\ntests across tmux 3.2a–3.7c. See the [compatibility matrix](docs/compatibility.md)\nfor exact versions and remaining platform coverage.\n\n## Read a server\n\nConnect to an existing server by its explicit socket path. This is the full\n[snapshot example](examples/snapshot.lua), which prints pane and window IDs:\n\n```lua\nlocal adapter = require(\"libtmux.runtime.luv\")\n\nlocal function must(value, err)\n    if err ~= nil then\n        error(err, 0)\n    end\n    return value\nend\n\nmust(adapter.run(function(runtime)\n    local server = must(runtime\n        :connect({\n            binary = assert(os.getenv(\"TMUX_BIN\"), \"set TMUX_BIN to an absolute tmux executable\"),\n            socket_path = assert(os.getenv(\"TMUX_SOCKET\"), \"set TMUX_SOCKET to an explicit socket\"),\n        })\n        :await())\n    local snapshot = must(server:snapshot({ strict = true }):await())\n    for _, pane in ipairs(snapshot.panes) do\n        io.stdout:write(pane.id, \"\\t\", pane.window_id, \"\\n\")\n    end\n    must(server:close():await())\n    return true\nend))\n```\n\nLive operations return Requests; `:await()` yields inside the runtime body and\nreturns `value, err`. The `must` helper propagates errors. Closing the connection\nleaves the tmux server and its sessions running.\n\nSet `TMUX_BIN` and `TMUX_SOCKET` to absolute paths for your server, then run:\n\n```console\n$ lua examples/snapshot.lua\n```\n\n<details>\n<summary>Try it on a temporary server</summary>\n\nRun from the checkout after installing the dependencies above. This starts a\nprivate tmux server and removes it when the example finishes.\n\n```console\n$ sh <<'SH'\nset -eu\nunset TMUX TMUX_PANE\nTMUX_BIN=$(command -v tmux)\ndemo_dir=$(mktemp -d /tmp/libtmux-lua-XXXXXX)\nTMUX_SOCKET=\"$demo_dir/tmux.sock\"\nexport TMUX_BIN TMUX_SOCKET\ncleanup() {\n    \"$TMUX_BIN\" -S \"$TMUX_SOCKET\" kill-server 2>/dev/null || true\n    rm -rf \"$demo_dir\"\n}\ntrap cleanup EXIT\n\"$TMUX_BIN\" -f /dev/null -S \"$TMUX_SOCKET\" new-session -d -s demo\nlua examples/snapshot.lua\nSH\n```\n\n</details>\n\n## Query captured state\n\nAfter capturing `snapshot` in the example above, filter its panes with\nstructured criteria or an ordinary Lua function:\n\n```lua\nlocal editors = snapshot.panes:where({\n    current_command = { one_of = { \"nvim\", \"vim\" } },\n})\nlocal inactive = snapshot.panes:filter(function(pane)\n    return not pane.active\nend)\n\nprint(#editors, #inactive)\nfor _, pane in ipairs(editors) do\n    print(pane.id, pane.current_command)\nend\n```\n\nSelections are dense, one-based Lua tables. Both queries read the snapshot\nwithout calling tmux. Capture again to refresh it; a snapshot spans multiple\ntmux commands and is not an atomic view.\n\nSee [criteria, relationships and live queries](docs/query.md), the\n[field reference](docs/fields.md), or run the\n[standalone table-query example](examples/native_query.lua):\n\n```console\n$ lua examples/native_query.lua\n```\n\n## Create sessions and panes\n\nBefore closing `server` in that runtime body, create a session and split a\nwindow. These calls use the same `must` helper:\n\n```lua\nlocal work = must(server:new_session({ name = \"work\" }):await())\nlocal editor = must(work.session:new_window({ name = \"editor\" }):await())\nlocal split = must(editor.pane:split({ direction = \"right\", percent = 40 }):await())\n\nmust(split.pane:send_text(\"printf '%s\\\\n' hello\"):await())\nmust(split.pane:send_keys({ \"Enter\" }):await())\n```\n\nCreation returns a table with `session`, `window`, `pane` and `window_link`\nhandles. These operations leave the new sessions and panes running. Sending\nkeys confirms that tmux accepted input; it does not wait for a shell command\nto finish. See [creation](docs/creation.md) and [pane operations](docs/panes.md)\nfor literal argv, capture, resize and cleanup.\n\n## Neovim\n\nFrom the checkout, start Neovim with the library on its `runtimepath`:\n\n```console\n$ nvim --cmd 'set runtimepath+=.'\n```\n\nWith `TMUX_SOCKET` set to an existing server's absolute socket path, run this\nLua code. `start` uses the editor's loop and reports the result in a callback:\n\n```lua\nlocal adapter = require(\"libtmux.runtime.nvim\")\n\nadapter.start(function(runtime)\n    local server, err = runtime:connect({\n        binary = vim.fn.exepath(\"tmux\"),\n        socket_path = assert(os.getenv(\"TMUX_SOCKET\")),\n    }):await()\n    if err then\n        return nil, err\n    end\n    return server:snapshot({ strict = true }):await()\nend, function(snapshot, err)\n    if err then\n        vim.notify(tostring(err), vim.log.levels.ERROR)\n        return\n    end\n    vim.notify((\"Panes: %d\"):format(#snapshot.panes))\nend)\n```\n\nThe runtime closes its connections when the body finishes and leaves the tmux\nserver running. See [runtime ownership and cancellation](docs/runtime.md).\n\n## Guides\n\n- **Clients:** [switch sessions and detach terminals](docs/clients.md).\n- **Read and watch:** [snapshots](docs/snapshots.md),\n  [session notifications and pane streams](docs/control.md).\n- **Run and arrange:** [commands and batches](docs/commands.md),\n  [session/window topology](docs/topology.md), [binary buffers](docs/buffers.md).\n- **Configure:** [options and hooks](docs/settings.md),\n  [option reference](docs/options-reference.md),\n  [environment values](docs/environment.md).\n- **Contribute:** [setup and validation](.github/CONTRIBUTING.md),\n  [writing conventions](.github/WRITING.md).\n\nLive tests use private sockets and clean up their own servers. See the\ncontributing guide for the same offline checks that run in CI.\n"
+    },
+    {
+      "path": "docs/runtime.md",
+      "content": "# Runtime ownership\n\nThe runtime schedules asynchronous requests and owns their cleanup.\nUse its [connection and snapshot API](snapshots.md) for explicit capture.\n[Literal command execution](commands.md) shares that connection. Named domain\noperations and observation are still being integrated.\n\nSelect `libtmux.runtime.luv` for a standalone Lua process. Its\n`run(body, limits)` function drives a quiescent top-level loop and returns\n`value, err` after owned work retires. It rejects coroutine entry, Neovim,\nactive borrowed handles and nested calls from a Lua-driven luv loop. A C host\nthat drives libuv without a Lua `uv.run` frame is outside this standalone\ncontract. Importing the adapter does not import luv or start a loop.\n\nSelect `libtmux.runtime.nvim` in Neovim. Its `start(body, on_done, limits)`\nfunction returns the runtime and root Request immediately. It borrows the\nhost loop and schedules callbacks outside fast events. `on_done(value, err)`\nruns after owned cleanup; unrelated host handles remain open.\n\n## Tasks and results\n\nThe body receives its runtime. `runtime:spawn(body)` creates a child task and\nreturns its Request eagerly. Tasks return `value, err`; a non-nil error or\nexception fails the enclosing task scope. Public library operations isolate\noperational failures in their returned Request; an unhandled failure in a\ncaller's spawned task still fails the root. Returning normally joins child\ntasks, requests and deferred callbacks. A task may yield only through\nruntime operations; arbitrary Lua CPU work is not preemptible.\n\n`request:await()` returns `value, err` from a managed coroutine in the same\nruntime. Main-thread, foreign-coroutine and cross-runtime waits raise\n`invalid_await_context`. Multiple tasks can wait on one Request.\n\n`request:on_complete(fn)` registers a deferred `fn(value, err)` callback.\nRegistration after settlement remains deferred while the runtime is live.\nRegistration after root retirement or closure raises `closed`; exceeding\ncallback or retained-byte limits raises `queue_full` synchronously.\nCallback failures fail their scope or appear in `runtime:errors()` when the\nscope has already failed or retired.\n\n`request:result()` reads a settled result without waiting; an unsettled\nrequest returns `nil, err` with code `pending`. `is_settled()` describes\ncaller completion. `is_retired()` describes transport cleanup. Cancellation\ncan settle before retirement, so these states differ.\n\n## Cancellation and limits\n\nThe task that creates an operation owns its cancellation. Canceling another\ntask that waits on that operation detaches its wait; it does not cancel the\nproducer. `request:cancel(reason)` cancels the requested operation explicitly.\n`runtime:close(reason)` rejects new work, cancels owned work and returns the\nroot Request; repeated close calls are safe.\n\nTransport errors preserve `effect`: `not_sent`, `unknown`, or `completed`.\nCanceling a tmux client cannot prove that accepted daemon work stopped.\nCleanup failures remain visible even when a result has already settled.\n\n| Limit | Default |\n| --- | ---: |\n| `max_active` | 16 |\n| `max_pending` | 128 |\n| `max_logical` | 128 |\n| `max_bytes` | 16 MiB |\n| `max_tasks` | 128 |\n| `max_callbacks` | 256 |\n| `max_resources` | 128 |\n| `dispatch_budget` | 64 |\n\nPass overrides as the adapter's `limits` table. Runtime counters are exposed\nby `runtime:stats()`. Byte accounting includes queued callback and waiter\ndelivery until transport retirement and delivery finish. Completed values\nretained by the caller belong to the caller's memory budget. Timers use\nmonotonic milliseconds and reject delays above 2,147,483,647 ms.\n\nLogical Requests represent one-shot waits owned by the runtime, such as an\nobservation's next event. They use the separate `max_logical` limit through\nretirement and do not occupy active or pending process slots. A normal root\nreturn joins these waits. Cancel them, close their producer, or supply a\ndeadline when no further event is expected. Canceling a borrowed waiter\nstill detaches that waiter without canceling the producer.\n\nPersistent native resources use private leases outside process slots. A\nlease can own one bounded byte reservation for its buffers; those bytes\ncount toward `max_bytes` and `stats().resource_bytes`. Internal producers\ncan release discarded bytes or transfer their reservation atomically to a\nsame-runtime, unsettled Request before delivering its value. The total\nruntime charge stays unchanged during transfer and lasts through queued\ndelivery. Closing the lease stops new retention and transfer; release\nremains available during cleanup. Cleanup must discard and release its\nbuffers before reporting completion. Unreleased bytes report\n`cleanup_failed`, remain charged, and increment `resources_failed` even\nafter the native close attempt ends. Leases and raw Request constructors\nremain private implementation APIs.\n\nStandalone host failures trigger bounded cleanup. If cleanup cannot finish,\n`cleanup_failed` reports remaining counters; it does not report successful\nretirement. The runtime never closes borrowed host loops or kills a tmux\nserver as part of request cancellation.\n\nSee [development checks](../.github/CONTRIBUTING.md) for real luv and Neovim\nhost probes and [compatibility targets](compatibility.md) for pending lanes.\n\nLuaLS 3.19.1 completes runtime, Request, Server and snapshot chains in both\nadapter bodies, including related pane/window fields. It preserves the\nstandalone `run` return type. That version does not infer the body result's\nmembers inside Neovim's separate `on_done` callback; annotate the callback's\nresult parameter explicitly when editor completion is needed there.\n"
+    },
+    {
+      "path": "docs/query.md",
+      "content": "# Query captured data\n\n`libtmux.query` filters ordinary Lua records without contacting tmux, starting\na loop, or loading a codec. Supply a schema for an ordinary sequence, including\nan empty one. [The native query example](../examples/native_query.lua) shows\nboth structured criteria and a Lua predicate over the same records.\n\n`query.select(rows, schema)` copies the sequence and retains the record objects.\nThe result is a dense one-based Lua table: indexing, `#` and `ipairs` behave\nnormally. `:where(criteria)` and `:filter(predicate)` return new selections.\nThey preserve input order, duplicate records and shared record references.\nThe input and returned tables remain mutable; they are not live views.\n\n| Operation | Result |\n| --- | --- |\n| `:first()` | First record, or nil |\n| `:one()` | Record, or `nil, no_match/multiple_matches` error |\n| `:one_or_nil()` | Zero or one record; multiple matches return an error |\n| `:exists()` / `:count()` | Whether any records exist / sequence length |\n| `:iter()` | Fresh local iterator yielding records |\n| `:to_table()` | Shallow sequence copy without selection methods |\n\nFree functions accept the sequence first and its schema last. A selection\ncarries its schema. `query.compile(schema, criteria)` returns a compiled handle\nor `nil, err`; `query.where(rows, compiled)` uses that handle's schema for\nordinary rows. Compilation copies the schema and criteria. Mutating their\noriginal tables cannot change the compiled query. Convenience validation errors\nraise structured error tables; `compile` and cardinality errors return them.\nTrusted predicates run as ordinary Lua and their errors propagate unchanged.\n\n## Criteria and projections\n\nSchema fields declare `string`, `number` or `boolean`, with optional `nullable`\nand `supported` booleans. Relations declare `cardinality = \"one\"` or `\"many\"`\nand a child `schema`. To-many arrays must describe the complete relationship.\n\nScalar criteria are equality shorthand; `false` is a value. Operators are\n`eq`, `ne`, `one_of`, `none_of`, `lt`, `lte`, `gt`, `gte`, `contains`,\n`starts_with`, `ends_with` and `is_null`. Strings compare literal bytes.\n`AND`/`OR` contain dense arrays of criteria; `NOT` contains one criterion.\nMultiple fields and operators imply AND. To-many relations use `some`, `every`\nor `none`; to-one relations use `is` or `is_not` with criteria or `query.NULL`.\n\n`query.NULL` represents a loaded absent nullable value or to-one relation.\nA missing key is unloaded. Unloaded and unsupported data produce errors even\ninside branches that would otherwise short-circuit. The entire grammar is\nvalidated first, then every required projection, then matching begins. Invalid\ncriteria fail even when the input is empty.\n\nEmpty criteria and `AND` match; empty `OR` and `one_of` do not; empty `none_of`\nmatches. On empty relationships, `some` is false and `every`/`none` are true.\nFor an absent to-one relation, `is = criteria` is false, `is_not = criteria`\nis true, `is = NULL` is true, and `is_not = NULL` is false.\n\nCriteria reject metatables, functions, cycles and non-finite numbers. Limits\nare depth 32, 4,096 copied nodes, 1,024 members per membership operator,\n65,536 aggregate string/key bytes and a conservative 524,288-byte encoding\nestimate. These limits bound criteria validation. Local row traversal and\narbitrary caller predicates are synchronous CPU work.\n\n## Versioned JSON criteria\n\n`query.encode_json(schema, criteria, codec)` returns a JSON string or `nil, err`.\n`query.decode_json(schema, text, codec)` returns new plain criteria tables or\n`nil, err`. Both validate the complete grammar against the supplied local\nschema. The wire does not supply its own schema or executable predicates.\n\nPass the consumer's codec explicitly. The supported interface is lunajson\n1.2.3's `encode(value, null)` and `newparser(text, callbacks)` SAX API; an\nordinary JSON `decode` function cannot preserve evidence of duplicate keys.\nCore imports and ordinary queries require only Lua. Codec functions are\ntrusted synchronous code; the library does not load a codec automatically.\n\n```lua\nlocal query = require(\"libtmux.query\")\nlocal json = require(\"lunajson\")\nlocal schema = { fields = { active = { type = \"boolean\" } } }\nlocal text = assert(query.encode_json(schema, { active = false, AND = {} }, json))\nlocal criteria = assert(query.decode_json(schema, text, json))\n```\n\nThis Lua API's versioned profile has exactly two envelope members:\n\n```json\n{\"version\":\"libtmux.where/v1\",\"where\":{\"active\":false,\"AND\":[]}}\n```\n\nProfile compatibility is scoped to this Lua API; cross-port conformance has\nnot been established. Wire operators retain their Lua spelling, including\nuppercase `AND`, `OR` and `NOT`. Unknown members and versions are rejected.\nSchema positions determine array versus object encoding: empty `AND`, `OR`,\n`one_of` and `none_of` use `[]`; empty criteria use `{}`. Decode rejects a\ncontainer of the wrong kind, including an empty object in an array position.\n`query.NULL` becomes JSON null and decodes back to the same sentinel. False\nremains false. Encoding marks arrays only in private copies and leaves caller\ncriteria and schemas unchanged.\n\nThe decoder rejects duplicate decoded keys, trailing non-whitespace, malformed\nUnicode, invalid UTF-8 and non-finite numbers. Wire numbers have magnitude at\nmost 9,007,199,254,740,991; nonzero number tokens that underflow to zero are\nrejected. Numbers otherwise use the host's floating-point representation.\nStrings containing arbitrary non-UTF-8 bytes remain usable in local criteria\nand require a separate binary representation at a consumer boundary.\n\nInput is capped at 524,288 bytes before constructing the SAX parser. Parsing\nchecks depth 32, 4,096 nodes and 65,536 aggregate decoded string/key bytes as\nevents arrive. Membership remains capped at 1,024 values. Encoding applies the\nsame wire budgets and output-byte cap. Envelope members and keys count toward\nwire limits, so criteria at a local limit may exceed a wire limit.\n\nErrors retain `code`, `operation`, `message` and `path`. `invalid_json` covers\nsyntax and scalar encoding failures, `invalid_wire` covers envelope/container\nshape, and `unsupported_wire_version` rejects another profile version.\n`invalid_codec` and `codec_error` report absent or failing injected codecs.\nExisting grammar errors and `query_limit` remain structured errors as well.\n\n## Query live state explicitly\n\n`server:query_panes(options)` returns a `Request<LiveQueryResult<Pane>>`.\n`server:query(options)` accepts `kind` for session, window, pane, window_link,\nclient or buffer records. Both return `rows`, a canonical Selection, plus the\ncaptured `snapshot`, executed `plan`, acquisition interval, `complete` flag\nand detected `races`. Collection methods on these results remain local.\n\nPass structured `where` criteria and choose a `pushdown` mode:\n\n| Mode | Behavior |\n| --- | --- |\n| `never` | Capture the graph and evaluate all criteria locally. |\n| `auto` | Also apply supported necessary pane predicates at the source. |\n| `require` | Reject an incomplete native translation before any listing. |\n\nNative translation currently supports bounded equality tests on selected pane\nIDs, booleans and integer fields. Other criteria remain local. AND can supply\nnecessary source predicates; partial OR, NOT and relationship predicates\ncannot. All entity kinds support local evaluation. `require` for another\nentity kind reports `unsupported_pushdown`.\n\n`server:explain_panes(options)` and `server:explain(options)` return Requests\nwith the ordered command phases, projections, relation hydration paths,\npushed predicates and residual reasons. Explaining performs no tmux I/O.\nInputs and projections validate before any live dispatch and are copied so\nlater caller mutation cannot change the query.\n\nThe `snapshot` option accepts [snapshot acquisition options](snapshots.md).\nRequired criterion fields are added to explicit projections. The current\nimplementation captures the whole relationship graph before an optional\nnative candidate listing. It preserves canonical order and linked-window\ncontext; filtering candidate IDs never removes children from quantified\nrelationships. This establishes semantics, not a performance advantage.\n\nThe graph and candidate listing cover different moments. `candidate_missing`\nreports a candidate absent from the captured graph; `candidate_changed`\nreports disagreement with a pushed predicate. `complete=true` means no known\ninconsistency, not an atomic view. `snapshot.strict` adds its one topology\nverification pass; it cannot freeze state across the later candidate listing.\nThe acquisition interval covers both phases. Snapshot and candidate listing\neach apply the requested row/byte limits; retained data also shares the\nruntime byte budget.\n\nExpert `native_filter` accepts an explicit pane format, up to 16 KiB. It is\nmutually exclusive with `where` and `pushdown`. It uses tmux's format language\nas supplied, has no equivalent local predicate, and receives no portability\nguarantee. Use structured criteria for untrusted data.\n\nThe [public live-query fixture](../tests/integration/live_query.lua) exercises\nlinked-window duplicates, projected fields, relationship quantifiers and an\nexpert filter through both adapters.\n"
+    },
+    {
+      "path": "docs/snapshots.md",
+      "content": "# Capture server state\n\nUse `runtime:connect(options):await()` to bind a borrowed tmux daemon, then\n`server:snapshot(options):await()` to capture its state. Every live operation\nreturns a Request. The [snapshot example](../examples/snapshot.lua) prints\neach unique pane and its window ID using the public API.\n\nPass an absolute `binary` and explicit absolute `socket_path` to `connect`.\nOptional `config_path` defaults to `/dev/null`. Connection options are copied\nbefore dispatch. The library does not select a default server or start one.\nImporting the library and inspecting captured records perform no I/O.\n\nConnection setup reads the actual daemon's version and identity. Linux socket\nbinding creates a private socket alias in the selected socket's parent\ndirectory; that directory must permit creation and hard links. Each command\nchecks the original socket and alias, reads bounded daemon evidence, and\ndisables tmux autostart. A restart, replaced socket or uncertain connection\ninvalidates the handle. Reconnect explicitly; old references do not bind to\nreused IDs. Tests currently cover Linux under WSL2. Native Linux and macOS\nremain separate unverified platform lanes.\n\n`server:close():await()` closes the handle and its owned connections. It leaves\nthe borrowed daemon running. The runtime also closes handles when its root\nscope finishes. Keep live work inside that scope; returning a handle from\n`adapter.run` does not keep its runtime alive.\n\n## Collections and projections\n\nSnapshots contain `sessions`, `windows`, `panes`, `window_links`, `clients`\nand `buffers` as [native selections](query.md). Canonical entity collections\ndeduplicate identity; `snapshot.raw` preserves contextual listing rows and\ntheir order. A window linked twice has two link rows and one canonical window.\nRelationships refer only to captured data. Clients are the attached clients\nthat tmux exposes through `list-clients`.\n\nWindow links own `session_id`, `window_id`, `index` and active context. Pane\nand window IDs remain tmux strings; Lua positions are not tmux indexes.\nA daemon with no sessions can still have buffers. Capture reads them without\ncreating a session.\n\nBy default, capture loads every supported field in the [catalog](fields.md).\nThe `fields` option maps collection names to nonempty field-name sequences;\nomitted collections keep their default projection. Required identity and\nrelationship fields are added. `requested_projections` records the caller's\nselection; `projections` records effective fields, including for empty\ncollections. Both maps use singular entity names such as `pane` and\n`window_link`. `capabilities.fields` records availability for the observed\ndaemon version; it does not claim every tmux command is supported.\n\nRefresh by calling `snapshot` again. It returns fresh records. Tables remain\nmutable, so do not edit them during traversal. Editing a record does not\nrefresh the server, another snapshot or its private identity index.\n\nCreate a handle with `server:handle(snapshot, record)`. The record's kind picks\nthe handle's class: a `SnapshotPane` gives a `libtmux.Pane`, a\n`SnapshotSession` a `libtmux.Session`, and so on, so LuaLS offers only the\nmethods tmux accepts for that kind. It copies the record's\nprivate identity, so edits to exposed `id` or `ref` fields cannot redirect it.\n`handle:reference()` returns a separate reference table without I/O.\n`handle:snapshot():await()` explicitly captures fresh state and returns the\nmatching record. A missing link/index, client/TTY or buffer name returns\n`target_missing`; stale server generations fail before capture. Same-name\nclient or buffer reuse cannot establish continuous object identity.\n\n## Consistency and limits\n\nCapture spans multiple commands. `acquisition.started` and `finished` are\nmonotonic milliseconds. Normal capture reports observed relationship races\nin `races` and sets `complete` to false. Transport failures return an error.\n\nSet `strict = true` for one additional identity/topology verification pass.\nIt compares membership and link context, ignoring listing order and volatile\nscalar values. A mismatch returns `inconsistent_snapshot` with the original\nsnapshot in `err.partial`; capture never retries to manufacture consistency.\n`verification` records the pass and its result. Equal observations do not\nmake capture atomic, prove continuous identity, or detect objects created\nand removed between reads. Replacing a named buffer can preserve every\ncatalog field while changing its contents.\n\nEach pass permits at most `max_rows` raw rows (default 65,536) across all\ncollections, before deduplication. `max_bytes` (default 16 MiB) limits both\ntotal encoded output and retained scalar/key bytes per pass. Strict mode\nadds one bounded pass. Accumulated rows and the graph copy also consume the\nruntime's byte budget; exhaustion returns `queue_full`. These counters bound\ndata, not exact Lua heap allocation.\n\n`timeout` defaults to 750 milliseconds per listing command. Endpoint evidence\nchecks have a separate bounded 750-millisecond deadline. Whole capture has\na finite command count; cancel its Request for an earlier stop. Closing the\nserver during capture prevents a successful current-reference result.\nCancellation retires owned clients; it does not kill the daemon.\n\nRun the example against an explicitly selected existing server:\n\n```console\n$ TMUX_BIN=/usr/bin/tmux TMUX_SOCKET=/tmp/example-tmux.sock lua examples/snapshot.lua\n```\n\nThe package gate runs this file from installed core and luv outside the\ncheckout, checks exact output, and verifies cleanup. Core-only installation\nstill has no luv dependency; this standalone example selects it explicitly.\n"
+    },
+    {
+      "path": "docs/creation.md",
+      "content": "# Create sessions, windows and panes\n\n`Server:new_session`, `Session:new_window` and `Pane:split` return a\n`Request<Creation>`. Await inside the adapter's managed coroutine, or register\n`on_complete(value, err)`. See [connections](snapshots.md) and\n[runtime ownership](runtime.md) for setup and cancellation.\n\nThe receipt contains `session`, `window`, `pane` and `window_link` handles\nmade from tmux's returned IDs. Its `created` sequence names the objects this\noperation created: all four for a session, window/pane/link for a window, and\nonly the pane for a split. Other handles describe the containing context.\nCreating a pane proves neither application readiness nor command success.\n\n## Commands and literal values\n\nPass `argv` for a literal command, or `shell` for explicitly authored tmux\nshell text. They are mutually exclusive. Multiple arguments use tmux's native\nargument execution. A singleton executable uses `/usr/bin/env --` to avoid\ntmux's single-argument shell interpretation; it requires that utility and\nrejects executable names containing `=`. Use explicit shell text for that\ncase. Omitting both fields uses tmux's configured default command or shell.\n\nNames, directories and environment values stay literal, including tmux\nformat-looking text. Session names reject `:`, `.`, and control bytes because\ntmux would otherwise change them. `environment` maps portable variable names\nto string values and applies to the created session or pane process through\ntmux's `-e` semantics. It does not change the caller's environment.\n\nAn explicit `cwd` must be an absolute existing directory. The asynchronous\npreflight rejects a missing directory before sending the creation command.\nFilesystem changes after validation remain possible. Input is copied and\nvalidated before dispatch, including nested process options.\n\n## Placement and selection\n\nSessions start detached and accept `name`, `window_name`, `width` and\n`height`. Windows accept `name`, an optional nonnegative `index`, and\n`select`; their parent is the Session handle's exact ID. A supplied occupied\nindex fails rather than replacing the existing window.\n\nSplits accept `direction` (`left`, `right`, `up` or `down`), optional positive\n`size` in cells or `percent` from 1 through 99, `full_size`, and `select`. The default\ndirection is down. New windows and splits leave selection unchanged unless\n`select=true`. Handle references cannot be edited to redirect an operation.\n\n## Errors and limits\n\n`process` accepts `timeout`, `deadline`, `max_output_bytes`, `kill_timeout`\nand `drain_timeout`; see [command completion](commands.md). It cannot replace\nthe bound socket, process environment, input stream or working directory.\nCreation accepts at most 1024 argv items, 128 environment entries and one MiB\nof encoded input, subject to the runtime's shared byte capacity.\n\nErrors preserve whether the command was not sent, may have taken effect, or\ncompleted. A malformed receipt reports `invalid_result` with completed effect\nand retained command output. Canceling the tmux client cannot undo a creation\nalready accepted by the daemon. Creation does not retry or remove partial\nstate. Closing the Server connection leaves created sessions running.\n\nThe [public creation fixture](../tests/integration/domain.lua) exercises the\nsame API through luv and Neovim with literal arguments, environment and\ndirectory values, returned IDs, explicit shell text and missing directories.\n"
+    },
+    {
+      "path": "docs/topology.md",
+      "content": "# Topology operations\n\nSession, Window, Pane and WindowLink handles perform explicit mutations through\nthe PROCESS endpoint. Each operation returns a Request that resolves to\n`true` when tmux successfully processes it. Refresh or capture a snapshot\nexplicitly to inspect the resulting state; existing records do not change\nin place.\n\n```lua\nassert(session:rename(\"build\"):await())\nassert(window:resize({ width = 120, height = 40 }):await())\nassert(window:layout({ named = \"tiled\" }):await())\n```\n\nThe [integration fixture](../tests/integration/topology.lua) includes setup,\nnative-state assertions and cleanup through both runtime adapters.\n\n## Names and removal\n\n`session:rename(name)` and `window:rename(name)` use their stable native IDs.\nNames are nonempty NUL-free strings up to 1,024 bytes. Session names also\nexclude dots, colons, ASCII controls and DEL. Format markers remain literal;\nnative name validation and cleaning still apply. Releases differ in accepted\nbytes and escaping, so success does not promise byte-exact storage. Exact\ntmux 3.7 also rejects dots and colons in Window names. Renaming a Window turns\noff its automatic rename option.\n\n`session:kill()` destroys that session and its links. A linked window can\nsurvive in another session. `window:kill()` destroys the window and **every**\nlink to it, potentially removing sessions left without windows. Neither\nmethod targets all other sessions or windows. Use these only for intended\nmutations; Request cancellation never implies either operation.\n\n## Window navigation\n\n`session:navigate_window(direction)` accepts `\"next\"`, `\"previous\"` or\n`\"last\"`. Next/previous support `activity = true` to select a window with a\nnative alert. Last rejects the `activity` option, including explicit false.\nNavigation changes the session's active window and follows native hooks and\ngrouped-session behavior.\n\n`session:renumber_windows()` renumbers from the session's `base-index` option.\nIt preserves Window IDs but invalidates captured link indices. It is a\nseparate operation from moving one window.\n\n## Window placements\n\nA WindowLink identifies one placement by session, index and Window ID. Use\n`creation.window_link` or a handle from `snapshot.window_links` when an\noperation needs that exact placement, including duplicate links in one\nsession. `link:select()` selects its index within its session.\n\n`link:link(destination)` creates another placement;\n`link:move(destination)` also removes this source placement. Destinations\naccept one of these plain records:\n\n- `{ session = session, index = 5 }` chooses an explicit index. Omitting\n  `index` requests a native free index from `base-index`, not append.\n- `{ link = anchor, position = \"before\"|\"after\" }` inserts relative to an\n  existing placement and may shift indices.\n- `{ link = victim, position = \"at\" }` requires `{ replace = true }` as the\n  operation options. Replacement can destroy the victim Window if it has no\n  other links. A numeric index alone never authorizes replacement.\n\nBoth operations default to `select = false`. Removal of an active source or\nreplacement of an active destination can still force native selection.\nOccupied numeric destinations return native errors; the library never\nsearches for a different destination or retries.\n\n`link:swap(other)` exchanges the Windows in two placements. By default,\nselected **slots** remain selected, although their Window identities change.\n`select = true` selects the destination slot, and the source slot when the\nsessions differ. Swapping two placements of the same Window is a native no-op.\n\n`link:unlink()` removes only this placement and refuses native last-link\ndestruction. `kill_if_last = true` permits that destruction. Grouped sessions\nretain tmux's synchronization and last-link rules. Native refusal is not\nrollback: insertion can shift indices before a later grouped-session error.\n\nEach operation checks the stored source tuple, and any destination link\ntuple, in the native command queue immediately before the mutation. A\nrecognized mismatch returns `stale_target`, `effect = \"not_sent\"`, and the\nnative receipt. Old handles never rebind automatically after index reuse,\nmovement or swapping. Recreating the identical tuple cannot be distinguished\nfrom continuous identity; native command aliases can also change these checks.\nThe [native-command contract](commands.md) applies to the generated guards\nand their mutation branches. They are not a transaction or an unconditional\ncompare-and-swap guarantee.\n\nSuccess returns `true`; capture a new snapshot explicitly to find resulting\nplacements. No predicted index or hidden post-mutation read constructs a new\nWindowLink handle.\n\n## Window size and layout\n\n`window:resize(options)` accepts exactly one form:\n\n- `width` and/or `height`, integers from 1 to 10,000.\n- `direction = \"left\"|\"right\"|\"up\"|\"down\"`, with `amount` from 1 to\n  10,000, defaulting to one.\n- `largest = true` or `smallest = true`, using tmux's native client-size rule.\n\nNative resizing sets `window-size` to manual. Layout constraints and available\nclient sizes can affect the result; the command's success is not a dimensions\noracle. Resizing affects every link to the Window.\n\n`window:layout(options)` also accepts exactly one form:\n\n- `named`: `even-horizontal`, `even-vertical`, `main-horizontal`,\n  `main-vertical` or `tiled`. The mirrored main layouts require tmux 3.5+.\n- `layout`: an exported native layout string with a four-digit hexadecimal\n  checksum, comma and body, bounded at 65,536 bytes.\n- `next = true`, `previous = true` or `restore = true`.\n\nMalformed custom-layout headers return `invalid_layout` before dispatch.\nThis avoids faulty error handling in tmux 3.3/3.3a and short-header reads in\nolder native parsers. Use `named` for standard layout names.\n\nLayout operations unzoom before native checksum and body validation. A rejected\nlayout can therefore change zoom state. A nonzero native exit carries its receipt\nand `effect = \"completed\"`; it does not establish rollback. Custom layout\nsyntax is tmux's grammar and is not evaluated as Lua or shell text.\n\n## Restart a window\n\n`window:respawn({ context = link, ... })` requires a WindowLink naming this\nWindow. Its session supplies the native launch context, including inherited\nenvironment. The link is checked in the native queue before respawn; the\nmethod never chooses an arbitrary session from a global Window ID.\n\nLaunch options match [creation](creation.md): literal `argv` or explicit\n`shell`, absolute `cwd` and a per-process `environment` map. Omitting launch\ntext reuses the previous command. Working-directory validation is asynchronous\nand completes before dispatch. `kill = true` permits replacement of running\nprocesses; otherwise tmux refuses an active window.\n\nRespawn retains the Window ID and its first Pane, removes sibling panes, and\nresets layout through every link to the Window. It can fail after destructive\npreparation; a native error does not establish rollback. Existing sibling\nPane handles do not become references to the restarted first Pane.\n\n## Move a pane\n\n`pane:move_to(target, options)` moves the same Pane into the target Pane's\nWindow. It defaults to a vertical split with `select = false`. Choose\n`direction = \"horizontal\"`, `size` from 1 to 10,000 cells, or `percent` from\n1 to 100. Size and percent exclude one another. `before = true` changes native\ngeometry; it does not promise a matching pane-index order. `full_size = true`\nextends the split across the Window.\n\n`select = true` requires `target_link = link`, identifying the exact placement\nwhose session and index will be selected. An optional target link also checks\nmembership when selection is disabled. The library checks that placement and\nthe target Pane's current Window separately in the native queue, then submits\nthe compound target. A moved target Pane produces `stale_target`; a target\nthat tmux cannot resolve can instead retain its native command error.\n\nMovement changes global pane membership through all Window links. Moving the\nlast Pane destroys the old Window and all its placements. Native layout and\nselection changes can happen before a later error. Moving a Pane preserves\nits ID and running process; it does not restart that process.\n\n## Break a pane into a window\n\n`pane:break_out(source_link, destination, options)` requires the Pane's exact\nsource WindowLink. Destinations accept a Session with an optional numeric\nindex, or an anchor WindowLink with `position = \"before\"|\"after\"`, as described\nunder [window placements](#window-placements). Replacement is not supported;\nan occupied numeric destination returns the native error.\n\nThe source placement and current Pane membership are checked in the native\nqueue, along with any destination anchor. The operation preserves the Pane ID\nand running process. With multiple panes, tmux creates a new Window and keeps\nthe source Window's links. With one pane, it moves the specified placement of\nthe existing Window; other links to that Window survive. `select` defaults to\nfalse, though removal of an active placement can force native selection.\n\n`name` follows the Window name rules above. Omitting it preserves native\nnaming: a singleton retains its existing Window name and options; a newly\ncreated Window takes the native default name and inherited options. An\nexplicit name disables automatic rename for the resulting Window.\n\nExact tmux 3.7 has a native multi-pane naming defect. The library supplies a\nplaceholder when no name is requested, avoiding the faulty native null-name\npath. For a named multi-pane break, it follows the break with a rename of the\nsame Pane's Window. This repair fires native rename notifications and\n`after-rename-window` hooks. Singleton breaks and other releases need no\nrepair. A repair failure can occur after the Pane has moved; it is not rollback.\n\n## Effects and boundaries\n\nOptions are copied before dispatch and must be plain records. These methods\naccept the same nested `process` limits as [Pane operations](panes.md).\nInput is bounded at one MiB per operation. A stale generation or invalid\ntarget fails before dispatch. If continuity is lost after successful native\ncompletion, the error preserves `effect = \"completed\"` and that receipt.\nMutations are never retried automatically.\n\nNative [aliases and hooks](commands.md) remain observable. These APIs do not\npromise transactions or protection against aliases that replace a built-in\ncommand.\n"
+    },
+    {
+      "path": "docs/panes.md",
+      "content": "# Pane operations\n\nPane handles perform explicit asynchronous operations through the pinned\nPROCESS endpoint. Each method returns a Request; await it inside a managed\nruntime task or use its completion callback. Snapshot records remain plain\ncaptured data. Obtain a handle from a creation receipt or `server:handle`.\n\n```lua\nlocal capture = assert(pane:capture({ history_lines = 20 }):await())\nlocal text = assert(capture:text())\nassert(pane:send_text(\"printf '%s\\\\n' ready\"):await())\nassert(pane:send_keys({ \"Enter\" }):await())\n```\n\nThe executable [integration fixture](../tests/integration/pane.lua) includes\nconnection setup, creation, output barriers and teardown.\n\n## Capture and text\n\n`capture()` returns `{ bytes, target }` with a pure `text()` method. `bytes`\npreserves tmux's stdout, including its terminal newline and invalid UTF-8.\n`text()` validates UTF-8 strictly and returns the same string; invalid input\nreturns `nil, err` with `invalid_utf8`. It performs no replacement, trimming,\nnewline conversion or tmux I/O.\n\nOrdinary capture reads rendered screen/history cells. It does not recover the\noriginal PTY byte stream, prove application completion, or establish an\nordered handoff to observation. It does not enter, exit or navigate copy mode.\n\nThe default captures the visible terminal screen. `history_lines = N` adds\nup to N history rows, bounded at 1,000,000. Alternatively, `start_line` and\n`end_line` accept integer row offsets or `\"-\"`: zero is the first visible row,\nnegative offsets refer to history, `start_line = \"-\"` selects all retained\nhistory and `end_line = \"-\"` selects the visible screen's end. Explicit ranges\ncannot be combined with `history_lines`. tmux clamps ranges to available data.\n\n| Option | Native behavior | Availability |\n| --- | --- | --- |\n| `join_lines` | Join wrapped rows and preserve trailing spaces (`-J`). | 3.2a+ |\n| `preserve_spaces` | Preserve trailing spaces (`-N`). | 3.2a+ |\n| `escape_sequences` | Include text/background attribute sequences (`-e`). | 3.2a+ |\n| `escape_nonprintable` | Request native octal escaping (`-C`). | 3.2a+ |\n| `alternate_screen` | Select tmux's alternate grid (`-a`); missing grid errors. | 3.2a+ |\n| `trim_empty_cells` | Omit trailing empty cells (`-T`). | 3.4+ |\n| `mode_screen` | Capture the active mode screen when available (`-M`). | 3.6+ |\n| `ignore_missing_alternate` | With `alternate_screen`, return one newline if the grid is missing (`-q`). | 3.2a+ |\n| `pending_escape_sequences` | Capture incomplete input held by tmux's parser (`-P`). | 3.2a+ |\n| `hyperlinks_only` | List native hyperlink URLs instead of cell text (`-H`). | 3.7+ |\n| `line_numbers` | Prefix rows with offsets relative to the visible screen (`-L`). | 3.7+ |\n| `line_flags` | Prefix rows with native grid flags (`-F`). | 3.7+ |\n\n`alternate_screen` cannot be combined with history, explicit ranges or\n`mode_screen`. Unsupported version flags fail before dispatch.\n\n`pending_escape_sequences` selects parser input instead of screen cells. Only\n`escape_nonprintable` and process limits apply; other enabled capture options\nare rejected. For example, a pending ESC followed by `[` produces `\"\\027[\\n\"`,\nor `\"\\\\033[\\n\"` with native octal escaping. The final newline belongs to tmux's\nprint output, not the pending input.\n\n`hyperlinks_only` preserves tmux's URL listing, including native deduplication\nand spacing. It does not guarantee an exhaustive URL inventory: tmux limits\nthe number of distinct links collected to the grid width. Screen/range\nselection, joined rows and line metadata still apply. Attribute sequences,\noctal escaping, preserved spaces and empty-cell trimming are rejected because\ntmux ignores them in this mode. No matches produce one newline.\n\n`line_numbers` and `line_flags` preserve native prefixes; with both enabled,\nthe number precedes the flags. Flags include `D`, `H`, `O`, `P`, `W` and `X`\nfor dead, hyperlink, output-start, prompt-start, wrapped and extended rows;\n`-` means none. The result remains bytes, not parsed row records.\n\nThe executable [capture fixture](../tests/integration/capture.lua) demonstrates\nthe supported capture modes with output barriers and cleanup.\n\n`capture_to_buffer(name, options)` writes directly to an explicit named buffer\nand returns `true` when the native command completes. It accepts the same\ncapture options and [buffer creation names](buffers.md#storage-and-identity).\nNonempty capture replaces the current slot. Empty capture leaves an existing\nbuffer unchanged and does not create a missing buffer; this includes empty\npending input and quiet missing alternate grids.\n\nBuffer capture stores native bytes without adding the print newline. A pending\nESC followed by `[` is stored as `\"\\027[\"`, whereas `capture()` returns\n`\"\\027[\\n\"`. Another client may replace the buffer before a subsequent read.\nProcess output limits bound client output, not storage inside the tmux daemon;\nuse a capture range to limit the selected rows.\n\n## Clear history\n\n`clear_history()` clears the pane's retained history and exits all its modes,\nincluding copy mode. It leaves visible screen cells intact. This is an\nexplicit shared-state mutation; cancellation of an unrelated Request never\ncalls it.\n\n`clear_history({ clear_hyperlinks = true })` also clears hyperlink storage,\nincluding links referenced by visible cells. This option requires tmux 3.4;\nolder versions return `unsupported` before changing history or mode state.\nSuccess returns `true` under the same process, generation and error contracts\nas the other Pane mutations.\n\n## Text, keys and copy mode\n\n`send_text(text)` sends bounded NUL-free UTF-8 with native `send-keys -l`.\nIt appends no Enter. A CR or LF already present in the argument remains\nexplicit caller input. It accepts at most 65,536 bytes; arbitrary binary\ninput is not part of this method.\n\n`send_keys(names, options)` accepts a dense sequence of up to 1,024 names.\nSupported names include Enter, Escape, Tab, BTab, Space, BSpace, arrows,\nHome/End, Insert/Delete and their IC/DC aliases, PageUp/PageDown aliases,\nF1–F12 and numeric keypad names. C-, M- and S- modifiers may prefix these\nnames or one printable ASCII character. Names are bounded at 64 bytes.\n`repeat_count` is an integer from 1 to 1,000. Typos return `invalid_key`;\nrecognized deferred native categories such as mouse and user-defined keys\nreturn `unsupported`. Unmodified literal characters belong in `send_text`.\n\nBoth methods preserve native mode and `synchronize-panes` behavior. Modes can\nintercept input; synchronization can copy it to sibling panes. Dead or\ninput-disabled panes can accept a command without delivering input. Success\nmeans tmux processed the operation, not that an application consumed it.\nThe library does not change these policies or infer shell-command success.\n\n`copy_mode({ page_up = true })` explicitly enters copy mode. `copy_command`\nsends one validated action through `send-keys -X`, with optional arguments\nand `repeat_count`. Entry, navigation and cancellation affect shared pane UI.\nNo automatic cleanup exits a mode that another client may be using.\n\nThe initial action subset includes cursor/word/paragraph/page/history\nnavigation, selection marking, rectangle modes, refresh, search and jumps.\nFor example:\n\n```lua\nassert(pane:copy_mode():await())\nassert(pane:copy_command(\"search-forward-text\", { \"ready\" }):await())\nassert(pane:copy_command(\"page-up\", {}, { repeat_count = 2 }):await())\nassert(pane:copy_command(\"cancel\"):await())\n```\n\nUnknown actions or incorrect argument counts return `invalid_copy_command`.\nRecognized deferred actions return `unsupported`, including copy/append,\nclipboard/pipe actions and newer navigation commands. This subset does not\nclaim complete native copy-mode parity. Native command completion does not\nguarantee a search match or cursor movement.\n\n## Resize, kill and respawn\n\n`resize({ width = N, height = N })` requests absolute dimensions;\n`resize({ direction = \"left\", amount = N })` adjusts one direction. Forms are\nmutually exclusive, dimensions/amount are 1–65,535 and adjustment defaults to\none. Native layout constraints can clamp the result, resize neighbors and\nunzoom the window. Obtain a fresh snapshot when the resulting geometry matters.\n\n`kill()` targets only the handle's pane ID. Native removal of the last pane\nalso destroys its window and can remove links or empty sessions elsewhere.\nThis is an explicit mutation; canceling another Request never calls it.\n\n`respawn(options)` reuses the same pane identity. Without `kill = true`, an\nactive pane produces a native error. Omitted `argv`/`shell` reuses its previous\nprogram; explicit launch options follow [creation](creation.md), including\nabsolute `cwd`, environment and separate literal argv/shell forms. Respawn\nresets the terminal screen and mode. It can terminate the old program before\na later spawn failure, and tmux success does not prove executable startup.\n\nThese methods return `true` on successful native completion. They preserve\ntyped errors and partial command output on failure, with no automatic retry.\nAll options must be plain records. The nested `process` record accepts timeout,\ndeadline, output limit and drain/kill timeouts as described in\n[commands](commands.md). Generation validation and runtime byte limits apply\nbefore dispatch; native completion still waits for client exit and both EOFs.\n\n## Selection, titles and swaps\n\n`select()` changes the window's shared active pane. It unzooms when changing\npanes unless `keep_zoom = true`. This explicit mutation affects other clients\nand can run native focus and selection hooks.\n\n`set_title(text)` sends format-literal UTF-8: `#{pane_id}` stays text. NUL,\nASCII control bytes and DEL are rejected before dispatch because native tmux\ncan silently ignore them. The limit is 65,536 bytes. Exact tmux 3.7 also\nsilently ignores empty titles, so that combination returns `unsupported`.\nOther accepted releases allow clearing the title. tmux's native name cleaning\nstill applies; from 3.7, backslashes can be doubled. Completion does not\npromise byte-exact storage for every accepted title.\n\n`swap(other_pane, options)` swaps two explicit, different panes from the same\nServer. Their stable IDs follow them into their new windows. The default uses\nnative `-d`: across windows, an active pane moved out is replaced at its old\nposition. Within one window, an active source pane can remain selected after\nmoving positions. Neither active identity nor active position is preserved in\nevery case. `select = true` uses native selection of the swapped panes.\n`keep_zoom = true`\npreserves each window's zoom. Swaps change inherited window options and the\npane relationships visible through every linked window.\n\nThese methods return `true` on native completion and share the process limits\nabove. Missing targets retain the native failure and its partial receipt.\nSee [topology operations](topology.md) for Session and Window mutations.\n"
+    },
+    {
+      "path": "docs/control.md",
+      "content": "# Observing a session\n\n`server:observe(session, options)` returns a Request for an observation lease.\nPass a session handle from that Server's snapshot or creation result. Concurrent\nleases for the same session share one owned persistent client. General commands\nuse the [process command API](commands.md).\n\nOpening verifies the pinned daemon before spawning and checks daemon evidence\nagain through the new connection. Every client\nuses `-N`; a missing session fails without creating a session or linking a\nwindow. Each endpoint owns at most eight observation clients.\n\nThe observation offers:\n\n- `watch_pane(pane, options)` returns a ready pane-output watch for a pane handle.\n- `watch_notifications(options)` returns a ready notification watch,\n  preserving unknown events and raw lines.\n- `subscribe_format(pane, field_names, options)` returns a typed native\n  format watch using generated pane fields.\n- `coverage()` returns copied session/pane coverage and connection generation.\n- `close()` closes this lease's watches; final close waits for native cleanup.\n\nHandles must belong to the same Server. Their copied private identities select\ntargets; overwriting a public `reference` method cannot redirect observation.\nOptions are copied on submission. Shared connection limits must agree across\nleases; conflicting options return `option_conflict`. Separate Server handles\nhave independent pools even when their socket paths match.\n\nCanceling acquisition releases only that caller's claim. Startup continues for\nremaining callers; canceling the final claim closes its client. Acquisition\nduring final cleanup returns `closing`. Await final `close()` before reopening;\na new connection has a distinct generation and requires new watches. A failed\nstartup also retains its pool entry until native cleanup finishes.\nA new acquisition on a failed shared connection returns its recorded loss\nerror. Close the old leases before opening a fresh connection.\n\nWatch creation installs its local receiver before a same-connection\n`list-panes` coverage check. A pane outside that session returns\n`uncovered_pane`. Topology changes invalidate reported coverage and close\naffected pane watches with `observation_gap`; opening a new watch performs\nanother bounded check. These checks are observations, not a topology\ntransaction. Capture remains a separate operation with no claimed lossless\nhandoff to the stream.\n\n## Reading and closing\n\n`watch:next({ timeout = milliseconds })` returns a Request for one event.\nAn absolute monotonic `deadline` is also supported. Only one read may be\npending on a watch; another returns `concurrent_read`. Canceling a read\ndetaches that waiter and leaves the watch usable. `watch:close()` is explicit\nand idempotent. An explicitly closed watch returns `nil, nil`; connection\nfailure or loss returns `nil, err`.\n\nPane events carry `kind = \"output\"`, `pane`, `data`, `sequence`, `generation`\nand `server_generation`. `data` is a Lua byte string, including NUL and\nnon-UTF-8 bytes. Extended output also preserves its decimal `age` and\n`metadata`. A sequence identifies ordering within one connection; it does\nnot imply complete pane history or application completion.\n\nFormat events carry `kind = \"format\"`, a typed `value`, and explicit\n`session_id`, `window_id`, window-link `index` and `pane` context. Only catalog\nfield names are accepted. Unknown or unsupported fields fail before writes;\ncaller text cannot introduce a format expression. Registration acknowledgement\nestablishes readiness. Native values arrive on tmux's\n[one-second sampling timer](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/control.c),\nso readiness does not wait for the first sample. Native title normalization\nand other daemon field behavior remain visible in the returned values.\nClosing a format watch unregisters its subscription.\n\n## Bounds and ownership\n\nDefaults are 128 pending housekeeping replies, 128 watches, 4 MiB of retained\nconnection data, and 1 MiB or 1,024 events per watch. Each observation claim,\nshared attachment and public watch consumes a runtime resource slot; the\ndefault runtime limit is 128 resources in total. Runtime byte and logical\nrequest limits also apply. Watch byte accounting includes event metadata;\nsubscription projections and queued encoded commands are charged before\ndeferred work begins.\n\nOverflow closes the affected watch with `observation_gap`. Its partial result\nreports discarded event count and decoded pane-byte count. Other watches and\nthe shared reader continue. Native `%pause` also invalidates pane continuity.\nThere is no silent drop policy, output coalescing, or claim that tmux pause is\nlossless backpressure.\n\nThe reader parses bounded slices independently of watch consumption. Completion\ncallbacks run through the runtime scheduler; application callbacks must not\nblock the shared Lua event loop. A persistent connection occupies a resource\nlease, not an active process slot. A pending `next` uses the separate bounded\nlogical-request lane.\n\nThe serialized writer accepts only private housekeeping operations. Arguments\nare encoded for tmux's control-line parser. Bootstrap has its own response;\nsubsequent replies use FIFO attribution and matching guard tuples. A request\ncanceled after a possible write leaves a connection-owned tombstone until its\nreply drains. A write or framing failure closes the connection and fails\npending callers. No command or pane input is retried or replayed.\n\nNormal root return closes resource leases after owned requests retire.\nEndpoint close or generation invalidation also closes its observation clients.\nNative cleanup waits for exit, pipe closure and pending write callbacks.\nPost-exit pipe drain is bounded at 250 ms. Explicit close first ends stdin;\nafter 100 ms it signals only the owned client, escalating after another\n100 ms. It never signals the tmux daemon or a pane program.\n\n## Attachment effects\n\nThe client uses `attach-session -E -f ignore-size,active-pane` with an exact\nsession ID. It issues no shared pane/window selection, resizing, detachment\nor session-environment updates. Native client listings, attachment state,\nfocus hooks and configured lifecycle policy remain observable. Hooks may\nthemselves change state; preservation fixtures use neutral hooks.\n\n`focus-events` stays unchanged. Disabling it cannot suppress every attachment\nfocus hook, and tmux provides no supported client flag for that guarantee.\nThe transport does not create hidden sessions or change window links. It\nomits `-r`: on tmux 3.7 and 3.7c, a read-only observer can make independent\nprocess-lane `send-keys` fail with \"client is read-only\". The private writer\nrestricts observation commands without that flag.\n\nClosing an observer removes its attached client. Native policy such as\n`destroy-unattached` can then destroy its session. A startup check cannot\nguarantee lifetime preservation when options or other clients can change.\nThe library does not rewrite borrowed options or retain hidden clients to\nprevent that policy.\n\nHousekeeping assumes the server's native command semantics. Aliases and hooks\ncan change even builtin commands; control framing does not authenticate server\noutput. This transport does not enable general command acceleration.\n\nAutomatic reconnect and subscription replay are not implemented. Opening a\nnew connection creates a distinct generation; callers must establish new\nwatches and treat the interval between connections as a gap.\n"
+    },
+    {
+      "path": "docs/commands.md",
+      "content": "# Execute tmux commands\n\nAfter [connecting](snapshots.md), `server:command(argv, options)` submits\nliteral tmux arguments and returns a Request. It preserves raw stdout/stderr\nbytes, exit code and signal, and waits for the owned client and its pipes to\nretire. A completed nonzero exit is returned as result data. Spawn, timeout,\noutput-limit and incomplete-drain failures return `nil, err`.\n\nNo shell parses argv. tmux still parses its own command syntax; the library\nprotects literal separator arguments. A tmux command that explicitly accepts\nshell text, such as `run-shell`, retains that command's shell semantics.\n\nNative command aliases apply even to full built-in names, including commands\nused by typed domain methods. Hooks can run additional commands and affect\nstate. The library does not change borrowed server configuration or promise\nthat aliases preserve built-in semantics. A preliminary configuration check\ncannot prevent an alias from changing before a later command is parsed.\n\nUse `server:group(commands, options)` for an explicit ordered tmux command\ngroup. Its result is aggregate output and exit status. Parse failure can\nreject the whole group, immediate execution failure skips later commands,\nand delayed WAIT-command failures can still allow later commands. A group\nprovides neither transactions nor independently attributed member results.\n\nOutput routing also follows tmux: `run-shell` without a pane target writes\njob output to pane view mode on tmux 3.3–3.4; tmux 3.2a and 3.5 onward\nwrite it to the waiting client's stdout. An explicit `-t` pane target\nselects pane output. Without `-b`, client completion still waits for the job,\nand a control-mode `%end` marker can precede that completion. See the upstream\n[stdout restoration](https://github.com/tmux/tmux/commit/fb37d52ddeccb603b0932b81cff3a6228f1fd83d).\n\nUse `server:batch(commands, { concurrency = n, process = options })` for\nindependent commands. Concurrency defaults to one and is bounded at 128;\nruntime capacity can reduce the active pool. The result is an input-indexed\narray of `completed`, `failed`, `unknown` or `skipped` outcomes, each with\n`effect` and optional `value`/`error`. Nonzero exits are failed outcomes with\ntheir actual result in `error.partial`. Other commands continue. A canceled\nbatch exposes a frozen `err.partial.outcomes` receipt; it preserves completed\nresults and distinguishes started work from work never sent.\n\nAll commands and process options are validated and copied before dispatch.\nOne submission accepts at most 1,024 commands, 4,096 total arguments and\n16 MiB of input. NUL is rejected in argv and environment entries; raw stdin\ncan contain it. Never retry mutations automatically, especially after an\nunknown effect. Canceling a client does not prove daemon work stopped.\n\nProcess options include `stdin`, `cwd`, explicit `env` entries, `timeout`,\nmonotonic `deadline`, `max_output_bytes` (default 1 MiB), `drain_timeout`\n(250 ms), and `kill_timeout` (100 ms). Timeout/deadline apply to the client\noperation; pinned endpoint evidence uses a separate bounded check. Output\nlimits and runtime byte admission remain distinct. Excess batch output is\nreported with byte counts and truncation metadata; it is not silently kept.\n\nThe raw API is an escape hatch. Named domain operations, owned command\ncompletion and observation APIs are still under development. A successful\n`send-keys` process does not report the exit of a pane application.\n"
+    },
+    {
+      "path": "docs/buffers.md",
+      "content": "# Read and paste named buffers\n\nBuffers hold bytes in the tmux daemon. Use an explicit name for every read,\nwrite, deletion and paste; these methods never infer the most recent buffer.\nEach live operation returns a Request through the PROCESS endpoint.\n\n```lua\nassert(server:set_buffer(\"build-output\", \"one\\000two\\n\"):await())\nlocal content = assert(server:show_buffer(\"build-output\"):await())\nassert(content.bytes == \"one\\000two\\n\")\nassert(pane:paste_buffer(\"build-output\", {\n    bytes = \"raw\",\n    linefeed_separator = true,\n}):await())\n```\n\nThe executable [integration fixture](../tests/integration/buffer.lua) includes\nconnection setup, owned pane readers, output barriers and teardown.\n\n## Storage and identity\n\n`server:set_buffer(name, bytes)` replaces the current value at that name.\nInput accepts one byte through one MiB, including NUL, invalid UTF-8 and\ntrailing newlines. It uses native stdin loading, so no shell or argv decoder\nprocesses the value. Empty input is rejected with `invalid_argument`: tmux\nwould accept it without creating or clearing a buffer. Delete explicitly to\nremove the value.\n\nNew names must be nonempty UTF-8, at most 4,096 bytes, without NUL, ASCII\ncontrols, DEL or backslash. The excluded creation forms return\n`unsupported_name`; some tmux releases accept them, while newer name cleaning\ncan change their stored key. Further native name validation still applies.\nSpaces, leading dashes and `#{...}` are literal. Buffer names do not undergo\ntmux format expansion.\n\nUse [`pane:capture_to_buffer(name, options)`](panes.md#capture-and-text) to\nstore a native pane capture directly. It uses these creation-name rules;\nempty capture leaves the named slot unchanged. Native buffer capture does\nnot add the newline used by capture's printed output.\n\n`server:show_buffer(name)` returns `{ name, bytes }` with a pure `text()`\nmethod. `bytes` preserves exact stdout. `text()` requires valid UTF-8 and\nperforms no trimming, replacement or newline normalization. Invalid UTF-8\nreturns `nil, err` with `invalid_utf8`. Mutating this returned record changes\nneither the daemon's value nor future Requests.\n\n`server:delete_buffer(name)` removes the current value on tmux 3.4 and later.\nIt returns `unsupported` before dispatch on 3.2a, 3.3 and 3.3a: those releases\ncan delete the most recent buffer when the requested name is missing. Checking\nexistence first would still race with other clients. This limitation does not\naffect `paste_buffer` with `delete_after`, whose native lookup rejects missing\nnames before deletion.\n\nRead, delete and paste accept broader exact observed names: nonempty NUL-free\nstrings up to 4,096 bytes. On supported operations, a missing buffer retains\ntmux's error and native receipt.\n\nA name identifies a current slot, not a persistent buffer incarnation. Another\nclient can replace its value after a snapshot or read. These methods operate\non the value present when tmux executes them; no preflight or transaction\nclaim hides that possibility.\n\n## Paste behavior\n\n`pane:paste_buffer(name, options)` targets the handle's exact pane ID and adds\nno Enter. Completion means the native command finished; it does not prove an\napplication received or consumed the bytes.\n\n| Option | Behavior |\n| --- | --- |\n| `bytes = \"native\"` | Default: preserve the connected daemon's native policy. tmux 3.7+ sanitizes control and invalid UTF-8 bytes; earlier releases paste raw bytes. |\n| `bytes = \"raw\"` | Disable that sanitization with `-S` on 3.7+; earlier releases already behave this way. Newline conversion remains separately controlled. |\n| `linefeed_separator = true` | Preserve LF. By default, tmux changes each LF to CR. |\n| `separator = text` | Replace each LF with this bounded NUL-free string, including empty. Excludes `linefeed_separator`, even explicit false. |\n| `bracket = true` | Add native bracketed-paste wrappers only when the pane has enabled that terminal mode. |\n| `delete_after = true` | Remove the named buffer after native paste processing. |\n\nInput-disabled panes can accept paste without receiving bytes, including a\nsuccessful `delete_after`. Paste does not use the send-keys dispatcher; do not\nassume its copy-mode or synchronized-pane routing. Native aliases and hooks\nremain observable as described in [command execution](commands.md).\n\n## Bounds and effects\n\nOptions must be plain records and are copied before dispatch. The nested\n`process` options accept timeout, deadline, output limit and drain/kill limits\nfrom [Pane operations](panes.md). Buffer output defaults to one MiB and cannot\nbe raised above that bound. Overflow returns an error with available partial\noutput, never a successful truncated BufferValue.\n\nRuntime input and output reservations remain charged through delivery.\nClosed or stale generations reject new work; continuity lost after native\nsuccess preserves `effect = \"completed\"` and the receipt. Cancellation after\ndispatch can have an unknown effect and never retries the mutation or kills\nthe target pane.\n\nBinary append, buffer renaming and explicit file load/save remain pending\ntyped APIs. No read-concatenate-write operation is presented as atomic.\n"
+    },
+    {
+      "path": "docs/clients.md",
+      "content": "# Switch and detach clients\n\nUse an explicit client name and TTY from a snapshot. A selector addresses the\ncurrent attachment at that name, including a replacement that attached after\nthe snapshot. Client records do not prove attachment continuity.\n\nInside a [runtime task](runtime.md), with a connected `server`, choose the\nclient and destination session by their observed names:\n\n```lua\nlocal snapshot = assert(server:snapshot():await())\nlocal observed = snapshot.clients:where({ name = \"/dev/pts/7\" }):one()\nlocal record = snapshot.sessions:where({ name = \"work\" }):one()\nlocal destination = assert(server:handle(snapshot, record))\nlocal selector = { name = observed.name, tty = observed.tty }\nassert(server:switch_client(selector, destination):await())\n```\n\n`switch_client` requires a Session handle from the same Server. Its private\nsession ID determines the destination; changing a returned reference cannot\nredirect the request. By default, switching preserves the destination's\nenvironment. Set `{ update_environment = true }` to apply the client's native\n`update-environment` values. Switching still triggers tmux's attachment,\nselection, sizing, focus and lifecycle effects.\n\n`server:detach_client(selector)` detaches that current client. It neither\ndetaches all clients nor requests a parent-process signal or shell command.\nSuccess means the native detach command completed; it does not mean the\nborrowed terminal process was reaped. Closing the library connection leaves\nother attached clients running.\n\nBoth methods return Requests that resolve to `true` on native completion.\nThe [owned-terminal fixture](../tests/integration/test_client.py) runs these\n[public API operations](../tests/integration/client.lua) through standalone\nLua and Neovim, including same-process reconnection and environment updates.\n\n## Selection and failure\n\nThe selector must be a plain record containing only `name` and `tty`.\nBoth are exact NUL-free byte strings of at most 4,096 bytes. `name` must be\nnonempty; `tty` may be empty for a client without a terminal. No implicit\ncurrent client or abbreviated name is selected.\n\nA fresh listing checks the complete name/TTY pair and native lookup aliases.\nMissing pairs return `missing_target`; multiple native matches return\n`ambiguous_target`. Neither dispatches a mutation. The listing and mutation\nare separate commands: another attachment can replace the selected client\nbetween them. No PID or timestamp check can prove continuity across native\ndetach/exec/reconnect. Use these methods only when addressing the current\nattachment is the intended operation.\n\nSelectors and options are copied before I/O. Closed handles and stale daemon\ngenerations reject work. A failure before mutation dispatch has\n`effect = \"not_sent\"`; cancellation after dispatch may have an unknown effect.\nContinuity loss after success retains the native receipt and\n`effect = \"completed\"`. Mutations are never retried automatically. Native\naliases and hooks follow the [command execution contract](commands.md).\n\nThe `process` options accept `timeout`, `deadline`, `max_output_bytes`,\n`drain_timeout` and `kill_timeout`. The output cap defaults to one MiB and\ncannot exceed it. Each subprocess has its own timeout; an absolute deadline\nalso bounds later subprocesses. Preflight accepts at most 1,024 client rows.\nMalformed or oversized listings fail without mutating a target. Runtime byte\ncapacity covers input, listing data and native receipts through delivery.\n\n## Interactive attachment\n\n`session:attach()` returns `unsupported_tty` before spawning: the current luv\nand Neovim adapters do not own an interactive terminal. It does not borrow\nthe editor's terminal or turn a control observation into an interactive\nattachment. Interactive terminal ownership, client navigation, key tables\nand read-only toggles remain pending capabilities.\n"
+    },
+    {
+      "path": "docs/environment.md",
+      "content": "# Persistent environment\n\nServer methods address tmux's global environment store. Session methods address\nthat session's local store. Each method returns a Request; reads never evaluate\nshell text. Window and Pane handles reject these operations with `invalid_scope`.\n\n```lua\nlocal adapter = require(\"libtmux.runtime.luv\")\nlocal result, err = adapter.run(function(runtime)\n    local server = assert(runtime:connect({\n        binary = \"/usr/bin/tmux\",\n        socket_path = \"/tmp/example-tmux.sock\",\n        config_path = \"/dev/null\",\n    }):await())\n    local snapshot = assert(server:snapshot():await())\n    local session = assert(server:handle(snapshot, snapshot.sessions[1]))\n    assert(server:set_environment(\"APP_MODE\", \"global\"):await())\n    assert(session:set_environment(\"APP_MODE\", \"local\"):await())\n    local local_value = assert(session:get_environment(\"APP_MODE\"):await())\n    assert(session:unset_environment(\"APP_MODE\"):await())\n    local inherited = assert(session:get_environment(\"APP_MODE\", { inherit = true }):await())\n    return { local_value = local_value, inherited = inherited }\nend)\nassert(result, tostring(err))\n```\n\nNames must match `[A-Za-z_][A-Za-z0-9_]*` and fit within 256 bytes. Native tmux\naccepts some other names; this API returns `unsupported_name` for them. Values\nare NUL-free byte strings up to one MiB. Empty strings, embedded newlines,\nquotes, dollar signs and invalid UTF-8 remain bytes without interpolation.\n\n## Reads and storage source\n\n`get_environment(name, options)` returns one record.\n`list_environment(options)` returns records sorted by portable name. Records\nhave these fields:\n\n| Field | Meaning |\n| --- | --- |\n| `name` | Portable name |\n| `state` | `value`, `removed`, or `absent`; lists omit absent names |\n| `value` | Exact bytes for `value`, including an empty string |\n| `hidden` | Native visibility flag; omitted when absent |\n| `scope` | Storage source: `global` or `session` |\n| `inherited` | Whether a session read used global fallback |\n| `target` | Session reference when the source is a session |\n\nReads default to local storage, with `inherit = false`. A session read with\n`inherit = true` uses global storage only when the name is absent locally.\nLocal hidden entries and removal markers suppress fallback. If both stores\nlack a named entry, the returned absent record describes the requested session.\n\nNamed reads detect hidden entries automatically. Lists include hidden entries\nby default; `include_hidden = false` omits them. An inherited list still reads\nlocal hidden entries to prevent a hidden override from exposing a global value.\nTreat returned hidden values as sensitive application data.\n\nThe optional `scope` must match the receiver: `global` for Server, `session`\nfor Session. `inherit = true` requires a session read. `include_hidden` applies\nonly to lists. Unsupported option combinations fail before I/O.\n\n## Mutations and inheritance\n\n`set_environment(name, value, { hidden = true })` stores a hidden value.\nOmitting `hidden` stores an ordinary value and clears an existing hidden flag.\n`unset_environment(name)` deletes the stored entry, allowing global fallback\nfor a session. `remove_environment(name)` installs a removal marker that blocks\nfallback and preserves the entry's existing native hidden flag. Each mutation\nreturns `true` after native completion.\n\nThese stores influence newly spawned processes. They do not change the\nenvironment of processes already running. A merged read is not an exact future\nprocess environment: tmux also supplies variables and may obtain PATH from the\ncreating client.\n\n## Consistency and bounds\n\nReads use literal `show-environment -s` arguments and a bounded decoder, never a\nshell evaluator. The decoder recognizes the thirteen catalog releases from\n3.2a through 3.7c. It reverses the 3.4–3.5a printer escapes and the additional\n3.4 variable-like dollar escape. Unsupported releases fail explicitly.\n\nA listing of a nonportable removal name can resemble several portable removal\nrows. Before returning a list, the library verifies each parsed removal through\nnamed reads in the same scope and visibility, in groups of at most 128 commands.\nMissing, duplicate, extra or changed verification rows produce `inconsistent`.\nThe verification uses aggregate group completion and makes no per-member effect\nclaims. Nonportable assignments fail decoding. This verification does not make\nmultiple reads a transaction: concurrent native changes can still occur between\nobservations. There is no automatic retry.\n\nAn operation reads at most one MiB of aggregate stdout and stderr and 4096\nsource entries, including both visibility views and global fallback. Verification\noutput counts toward the byte limit. Runtime capacity accounts for copied\ninput, raw output and decoded records through callback delivery. Capacity and\nprotocol errors return no partial list.\n\n`process` accepts `timeout`, `deadline`, `max_output_bytes`, `drain_timeout` and\n`kill_timeout`; its output limit cannot exceed one MiB. A timeout applies to each\nnative client; an absolute deadline also bounds later clients. Process stdin,\nenvironment and working-directory overrides are unavailable here.\n\nClosed handles and stale generations reject dispatch or publication. Once a\nclient is sent, cancellation cannot undo accepted daemon work. Native errors\nretain their receipt; decoding or consistency failures after successful reads\nhave `effect = \"completed\"`.\n"
+    },
+    {
+      "path": "docs/settings.md",
+      "content": "# Options and hooks\n\nOptions and hooks return Requests through the process lane. Session, Window\nand Pane handles select their own storage scope. Server methods default to\nserver options; use `scope = \"global_session\"` or `\"global_window\"` for global\ndefaults. Server hook methods require one of those explicit global scopes.\nThere is no global pane scope. A scope that conflicts with the handle or\nbuilt-in definition fails before I/O.\n\nThe [release catalog](options-reference.md) records exact names, types and\nscopes for supported tmux releases. Names do not accept tmux's abbreviations.\nUnknown releases fail with `unsupported_version`. User options support names\nsuch as `@project_name`, with ASCII letters, digits, underscores, dots and\nhyphens after `@`; broader native names return `unsupported_name`.\n\n## Read a setting\n\n`get_option(name, options)` returns a record with `present`, `inherited`,\n`type`, requested `scope` and `target`. Scalar `value` preserves booleans,\nintegers and bytes. Choice values use their canonical names. Keys, colours,\nstyles and command options return native canonical text. Reads never execute\nthat text. `list_options(options)` returns records sorted by name.\n\nReads include inherited values by default. Set `inherit = false` to inspect\nonly the selected table. `present = false` distinguishes absence from an\nempty string, `false` or an explicit empty array. Local and inherited reads\nare separate observations; concurrent changes can occur between them.\n\nArrays return ordered `entries`, each with a native zero-based `index` and\n`value`. Indices may have gaps. An `index` read option selects a slot after\nreading the complete array, preserving the distinction between an absent\nslot and an empty string. An absent slot has `present = false` and no entries.\n\n## Change a setting\n\n`set_option(name, value, options)` accepts booleans for flags, integers within\nthe release-specific range, exact choice names and NUL-free strings for\nstring, key, colour and style options. Native key, colour and style grammar\nis still checked by tmux. Command values use the program record described\nbelow. Input structure, types, bounds and scopes are checked before I/O.\n\nUse `index` to write one array slot. To replace a sparse array, supply\n`{ entries = { { index = 0, value = \"first\" }, ... } }`. The library copies and\nvalidates the whole input, clears the local array, then writes slots in index\norder in one stop-on-error command group. Empty entries create an explicit\nempty local array. A first local indexed write also creates a local array;\nit does not copy inherited slots.\n\nReplacement is not atomic. Native value validation or hooks may fail after\nan earlier write; the returned error preserves the process result without\nclaiming which slots completed. tmux can run hooks between group commands.\n\n`append = true` concatenates a scalar string or an indexed string-array value.\nWhole-array append is unsupported: native separator splitting cannot preserve\narbitrary string elements. Indexed colour or command append is rejected\nbecause tmux replaces those values instead of appending.\n\n`unset_option(name, options)` removes a local override, restoring inheritance.\nFor global defaults it restores tmux's default. An optional `index` removes\none array slot. The API never uses tmux's wider `-U` operation, which can also\nremove pane overrides.\n\n## Store and run hook programs\n\n`set_hook(name, program, options)` stores a tmux command program. Supply exactly\none of `commands`, a dense sequence of argv sequences, or `source`, explicit\ntmux program text. `commands` encodes each argument as literal tmux-parser\ndata in one command group. Commands retain their own native format and shell\nsemantics. `source` is not pre-parsed; tmux aliases and grammar are resolved\nby tmux. Neither form is evaluated as Lua.\n\nUse `index` for a built-in hook slot. Without an index, setting a built-in hook\nreplaces its array with one program. `append = true` adds a program at the first\nfree native slot. Indexed append is rejected because native command-array\nappend replaces that slot. Invalid native source can clear an existing array\nbefore tmux reports failure; storing a hook is not transactional.\n\n`get_hook` and `list_hooks` return the same presence and inheritance metadata\nas options. Built-in hooks have sparse `entries` containing `index` and\ncanonical program `source`. Canonical text may expand aliases or reorder\nflags; it does not reconstruct the original argv. Custom `@` hooks return a\nsingle `source`. They can be retrieved by name but are omitted from\n`list_hooks`, since tmux cannot distinguish them from ordinary user options.\n`unset_hook` removes the selected hook or slot.\n\nSession, Window and Pane handles offer `run_hook(name, options)`. Execution\nuses that live context's native hook lookup. Only process limits are accepted;\nstorage scopes, indices, append and replacement source do not select a hook\nfor execution. Custom hook execution requires tmux 3.3 or newer. A successful\nprocess result means tmux completed its command; malformed custom source may\nstill be ignored by tmux without an error.\n\n## Bounds and failures\n\nSettings use at most one MiB of encoded input and aggregate native output.\nListings accept at most 4096 rows. Array replacement accepts at most 512\nentries and remains subject to the aggregate argv and byte limits. Programs\naccept at most 1024 commands, 4096 arguments and one MiB after encoding.\n\n`process` accepts deadline, timeout, output and cleanup limits. Caller-provided\nprocess environment, cwd and stdin are rejected. Output preserves bytes even\nwhen the caller uses a C locale. No operation changes the caller's environment.\n\nCanceling a client does not undo accepted tmux mutations. Errors distinguish\n`not_sent`, `unknown` and `completed` effects. A stale handle detected after a\ncompleted command retains that completed effect; it does not imply rollback.\n"
+    },
+    {
+      "path": "docs/fields.md",
+      "content": "# tmux field catalog\n\nThis curated catalog describes the scalar fields needed by the core entity\nmodel. It does not enumerate every tmux format. Edit\n[the source catalog](../data/tmux-fields.json) and regenerate this reference\ntogether with Lua metadata and LuaLS field annotations:\n\n```console\n$ python scripts/generate_fields.py\n```\n\nCheck generated files without changing them:\n\n```console\n$ python scripts/generate_fields.py --check\n```\n\nGeneration uses Python and the pinned StyLua formatter; it needs no network\nor tmux process. The optional `--verify-source` argument accepts a local tmux\nGit checkout and verifies every pinned format mapping and source anchor.\n\n## Availability and values\n\n`Since` means the first release supported by this catalog for that field,\nnot necessarily the release that introduced it. The floor is tmux 3.2a.\nSource inspection establishes format availability; it does not establish\ncomplete runtime or platform compatibility. Later release strings retain\nknown fields; development and prerelease strings require explicit capability\nevidence and are rejected by the schema helper.\n\nRecord names are Lua aliases for literal tmux format names. IDs retain their\n`$`, `@`, and `%` prefixes. `number` fields represent integers; consumers must\nreject values outside the exact integer range of their Lua runtime rather\nthan silently round them. All generated LuaLS fields are optional because a\nprojection may leave a field unloaded.\n\nNullable fields may be absent within an otherwise valid native context.\nLoaded absence uses `query.NULL`; an omitted key means not loaded. Known\nfields unavailable at the requested version remain in the query schema with\n`supported = false`. Empty text remains text for nonnullable string fields.\nThe scalar catalog does not build relationships or perform I/O.\n\nWindow index, active state, and flags belong to `window_link`. Windows and\npanes have no scalar session ID because a window can be linked into several\nsessions. `client_session` provides a session name, not a session ID. Client\nnames and buffer names need contextual revalidation before later mutations.\n\n## Source provenance\n\n- floor: [3.2a](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/format.c).\n- added: [3.3](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/format.c).\n- stable: [3.7c](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c).\n- upstream: [inspected upstream revision](https://github.com/tmux/tmux/blob/e880cf63e0a9fe095d7c5d313761520fb1a8653c/format.c).\n\n## Server\n\n| Record field | tmux format | Type | Nullable | Since | Native scope |\n| --- | --- | --- | --- | --- | --- |\n| `pid` | [`pid`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L541) | number | no | 3.2a | server |\n| `socket_path` | [`socket_path`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2690) | string | no | 3.2a | server |\n| `version` | [`version`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2697) | string | no | 3.2a | server |\n| `start_time` | [`start_time`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L3107) | number | no | 3.2a | server |\n\n- `pid`: Daemon process ID.\n- `socket_path`: Socket path reported by the daemon.\n- `version`: Daemon version string.\n- `start_time`: Daemon start time in Unix seconds.\n\n## Session\n\n| Record field | tmux format | Type | Nullable | Since | Native scope |\n| --- | --- | --- | --- | --- | --- |\n| `id` | [`session_id`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2630) | string | no | 3.2a | session |\n| `name` | [`session_name`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2663) | string | no | 3.2a | session |\n| `created` | [`session_created`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L3089) | number | no | 3.2a | session |\n| `activity` | [`session_activity`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L3080) | number | no | 3.2a | session |\n| `attached` | [`session_attached`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2553) | number | no | 3.2a | session |\n| `window_count` | [`session_windows`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2681) | number | no | 3.2a | session |\n| `group` | [`session_group`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2571) | string | yes | 3.2a | session |\n| `grouped` | [`session_grouped`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2618) | boolean | no | 3.2a | session |\n| `path` | [`session_path`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2672) | string | no | 3.2a | session |\n\n- `id`: Session ID, including its dollar-sign prefix.\n- `name`: Session name.\n- `created`: Creation time in Unix seconds.\n- `activity`: Last activity time in Unix seconds.\n- `attached`: Attached client count, not a boolean.\n- `window_count`: Number of window links in this session.\n- `group`: Session group name; absent for an ungrouped session.\n- `grouped`: Whether this session belongs to a group.\n- `path`: Session working directory.\n\n## Window\n\n| Record field | tmux format | Type | Nullable | Since | Native scope |\n| --- | --- | --- | --- | --- | --- |\n| `id` | [`window_id`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2844) | string | no | 3.2a | window |\n| `name` | [`window_name`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2936) | string | no | 3.2a | window |\n| `width` | [`window_width`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L3015) | number | no | 3.2a | window |\n| `height` | [`window_height`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2835) | number | no | 3.2a | window |\n| `pane_count` | [`window_panes`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2973) | number | no | 3.2a | window |\n| `layout` | [`window_layout`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L839) | string | yes | 3.2a | window |\n| `visible_layout` | [`window_visible_layout`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L853) | string | yes | 3.2a | window |\n| `zoomed` | [`window_zoomed_flag`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L3024) | boolean | no | 3.2a | window |\n\n- `id`: Window ID, including its at-sign prefix.\n- `name`: Window name.\n- `width`: Width in character cells.\n- `height`: Height in character cells.\n- `pane_count`: Number of panes owned by this window.\n- `layout`: Layout including panes hidden by zoom; absent without a layout tree.\n- `visible_layout`: Visible layout; absent without a layout tree.\n- `zoomed`: Whether this window is zoomed.\n\n## Window link\n\n| Record field | tmux format | Type | Nullable | Since | Native scope |\n| --- | --- | --- | --- | --- | --- |\n| `session_id` | [`session_id`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2630) | string | no | 3.2a | session |\n| `window_id` | [`window_id`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2844) | string | no | 3.2a | window |\n| `index` | [`window_index`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2853) | number | no | 3.2a | winlink |\n| `active` | [`window_active`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2737) | boolean | no | 3.2a | winlink |\n| `flags` | [`window_flags`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2817) | string | no | 3.2a | winlink |\n\n- `session_id`: Session owning this contextual link.\n- `window_id`: Underlying window shared by links.\n- `index`: tmux index within the session, not Lua array position.\n- `active`: Whether this link is the session current window.\n- `flags`: Printable flags for this session/window link.\n\n## Pane\n\n| Record field | tmux format | Type | Nullable | Since | Native scope |\n| --- | --- | --- | --- | --- | --- |\n| `id` | [`pane_id`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2152) | string | no | 3.2a | pane |\n| `window_id` | [`window_id`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2844) | string | no | 3.2a | window |\n| `index` | [`pane_index`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2161) | number | no | 3.2a | pane |\n| `active` | [`pane_active`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2028) | boolean | no | 3.2a | pane |\n| `title` | [`pane_title`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2384) | string | no | 3.2a | pane |\n| `width` | [`pane_width`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2411) | number | no | 3.2a | pane |\n| `height` | [`pane_height`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2143) | number | no | 3.2a | pane |\n| `left` | [`pane_left`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2225) | number | no | 3.2a | pane |\n| `top` | [`pane_top`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2393) | number | no | 3.2a | pane |\n| `pid` | [`pane_pid`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2285) | number | no | 3.2a | pane |\n| `tty` | [`pane_tty`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2402) | string | no | 3.2a | pane |\n| `current_path` | [`pane_current_path`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L915) | string | yes | 3.2a | pane |\n| `current_command` | [`pane_current_command`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L891) | string | yes | 3.2a | pane |\n| `start_command` | [`pane_start_command`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L865) | string | no | 3.2a | pane |\n| `dead` | [`pane_dead`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2075) | boolean | no | 3.2a | pane |\n| `dead_status` | [`pane_dead_status`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2106) | number | yes | 3.2a | pane |\n| `dead_signal` | [`pane_dead_signal`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2089) | string | yes | 3.3 | pane |\n| `dead_time` | [`pane_dead_time`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2120) | number | yes | 3.3 | pane |\n| `mode` | [`pane_mode`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2258) | string | yes | 3.2a | pane |\n| `mode_count` | [`pane_in_mode`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1138) | number | no | 3.2a | pane |\n| `synchronized` | [`pane_synchronized`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L2372) | boolean | no | 3.2a | pane |\n\n- `id`: Pane ID, including its percent-sign prefix.\n- `window_id`: ID of the window that owns this pane.\n- `index`: tmux pane index within its window.\n- `active`: Whether this pane is active in its window.\n- `title`: Pane title; an empty title remains an empty string.\n- `width`: Width in character cells.\n- `height`: Height in character cells.\n- `left`: Left cell offset in the window.\n- `top`: Top cell offset in the window.\n- `pid`: PID recorded for the pane process.\n- `tty`: Pseudo-terminal name; empty is preserved.\n- `current_path`: Process working directory when the OS can determine it.\n- `current_command`: Displayed command name; absent without pane shell context.\n- `start_command`: Stringified startup argv; this is not a shell-safe command.\n- `dead`: Whether tmux has a ready dead-process status.\n- `dead_status`: Exit status only when the process exited normally.\n- `dead_signal`: Signal name only when the process terminated by signal.\n- `dead_time`: Dead-pane display time in Unix seconds, when available.\n- `mode`: Top mode name; absent outside pane modes.\n- `mode_count`: Number of active modes, not a boolean.\n- `synchronized`: Effective synchronize-panes option.\n\n## Client\n\n| Record field | tmux format | Type | Nullable | Since | Native scope |\n| --- | --- | --- | --- | --- | --- |\n| `name` | [`client_name`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1539) | string | no | 3.2a | client |\n| `tty` | [`client_tty`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1623) | string | no | 3.2a | client |\n| `pid` | [`client_pid`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1548) | number | no | 3.2a | client |\n| `session_name` | [`client_session`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1584) | string | yes | 3.2a | client |\n| `width` | [`client_width`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1677) | number | yes | 3.2a | client |\n| `height` | [`client_height`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1510) | number | yes | 3.2a | client |\n| `control_mode` | [`client_control_mode`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1480) | boolean | no | 3.2a | client |\n| `readonly` | [`client_readonly`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1572) | boolean | no | 3.2a | client |\n| `created` | [`client_created`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L3071) | number | no | 3.2a | client |\n| `activity` | [`client_activity`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L3062) | number | no | 3.2a | client |\n\n- `name`: Observed client name; not a persistent identifier.\n- `tty`: Observed terminal name; empty is preserved.\n- `pid`: Client process ID.\n- `session_name`: Attached session name, not a session ID.\n- `width`: Terminal width; nullable without a started TTY.\n- `height`: Terminal height; nullable without a started TTY.\n- `control_mode`: Whether this is a control-mode client.\n- `readonly`: Whether this client is read-only.\n- `created`: Creation time in Unix seconds.\n- `activity`: Last activity time in Unix seconds.\n\n## Buffer\n\n| Record field | tmux format | Type | Nullable | Since | Native scope |\n| --- | --- | --- | --- | --- | --- |\n| `name` | [`buffer_name`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1416) | string | no | 3.2a | buffer |\n| `size` | [`buffer_size`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1449) | number | no | 3.2a | buffer |\n| `sample` | [`buffer_sample`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L1425) | string | no | 3.2a | buffer |\n| `created` | [`buffer_created`](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/format.c#L3048) | number | no | 3.2a | buffer |\n\n- `name`: Buffer name; revalidate before later mutations.\n- `size`: Buffer size in bytes.\n- `sample`: tmux printable preview; not complete buffer bytes.\n- `created`: Creation time in Unix seconds.\n"
+    },
+    {
+      "path": "docs/options-reference.md",
+      "content": "# tmux option and hook reference\n\nThis generated catalog records every canonical built-in option and hook\nin the 13 released tmux versions listed below. It describes native types\nand storage scopes; it does not establish runtime or platform compatibility.\nEdit [the catalog](../data/tmux-options.json), then regenerate:\n\n```console\n$ python scripts/generate_options.py\n```\n\nCheck generated Lua metadata and this reference without changing files:\n\n```console\n$ python scripts/generate_options.py --check\n```\n\nBoth commands run offline with Python and the pinned StyLua formatter.\n`--verify-source` additionally accepts a local tmux Git checkout and checks\nevery release tag, pinned source digest, definition and line anchor. It\ndoes not download sources, build tmux or start a server.\n\n## Values and scopes\n\nBuilt-in names select their native storage scope; command flags alone do\nnot enforce the caller's intended scope. Session and window defaults are\nseparate global stores. Pane-capable options also support window storage;\nthere is no global pane store. Unknown release strings require new source\nevidence: the private catalog does not fall back to the latest version.\n\nFlags use booleans, numbers use exact bounded integers, and choices use\nliteral strings, including numeric-looking choices such as `\"24\"`. Keys,\ncolours, styles and commands retain their native string grammars. A command\nvalue is tmux command-list source, not shell argv. Native grammar validation\nand remote conditions such as shell suitability still require tmux.\n\nArrays retain native zero-based sparse indices and their element type.\nThe separator is a set of splitting characters, not a reversible codec.\nAn omitted array separator means space/comma; an empty separator preserves\none complete command-list entry. Indexed assignment avoids splitting.\nAll built-in hooks are command arrays; a scalar command option is not a\nhook. User options beginning with `@` are separate string scalars.\n\nGlobal built-in unset restores the default; local unset removes an override.\nNative aliases, prefix matching, default values and descriptive option text\nare outside this catalog. Source integer limits assume the supported target\nABIs' 32-bit `int` and 16-bit `short`; the largest bound is 4294967295.\n\n## Source releases\n\n| Release | Built-ins, including hooks | Hooks |\n| --- | ---: | ---: |\n| [3.2a](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c) | 165 | 61 |\n| [3.3](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c) | 181 | 65 |\n| [3.3a](https://github.com/tmux/tmux/blob/0b355ae8114511e1ff6359272b164f1cdf718e80/options-table.c) | 181 | 65 |\n| [3.4](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c) | 186 | 65 |\n| [3.5](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c) | 190 | 66 |\n| [3.5a](https://github.com/tmux/tmux/blob/549c35b06165f6ae023115eb76f83f2cbf945395/options-table.c) | 190 | 66 |\n| [3.6](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c) | 210 | 68 |\n| [3.6a](https://github.com/tmux/tmux/blob/cc117b5048f77a4842820f8ebbe3a86e5c077224/options-table.c) | 210 | 68 |\n| [3.6b](https://github.com/tmux/tmux/blob/0623d1e968423ad0c192e0d8debf1258671063d5/options-table.c) | 210 | 68 |\n| [3.7](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c) | 221 | 68 |\n| [3.7a](https://github.com/tmux/tmux/blob/0e418b62d259ce8da8970f75732cc6632ee4c3a0/options-table.c) | 221 | 68 |\n| [3.7b](https://github.com/tmux/tmux/blob/e802909de06012a4df6209d55e86487c56223163/options-table.c) | 221 | 68 |\n| [3.7c](https://github.com/tmux/tmux/blob/e476c1230b958df0cb12977517d24b3dc931375b/options-table.c) | 221 | 68 |\n\nFull commit identities, hashes for `options-table.c`, `options.c` and\n`tmux.h`, and per-entry source anchors are recorded in the source catalog.\nRepeated release labels below mean the extracted metadata is identical,\nnot that defaults or other native behavior are identical.\n\n## Options\n\n| Name | Releases | Scope | Value | Array separator |\n| --- | --- | --- | --- | --- |\n| [`activity-action`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L346) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `none`, `any`, `current`, `other` | — |\n| [`aggressive-resize`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L753) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | flag | — |\n| [`allow-passthrough`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L804) | 3.3, 3.3a | window, pane | flag | — |\n| [`allow-passthrough`](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c#L859) | 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | `off`, `on`, `all` | — |\n| [`allow-rename`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L763) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | flag | — |\n| [`allow-set-title`](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c#L900) | 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | flag | — |\n| [`alternate-screen`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L771) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | flag | — |\n| [`assume-paste-time`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L354) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..2147483647 | — |\n| [`automatic-rename`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L779) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | flag | — |\n| [`automatic-rename-format`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L786) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`backspace`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L193) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | key | — |\n| [`base-index`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L365) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..2147483647 | — |\n| [`bell-action`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L374) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `none`, `any`, `current`, `other` | — |\n| [`buffer-limit`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L200) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | 1..2147483647 | — |\n| [`clock-mode-colour`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L794) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | colour | — |\n| [`clock-mode-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L801) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a | window | `12`, `24` | — |\n| [`clock-mode-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1093) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `12`, `24`, `12-with-seconds`, `24-with-seconds` | — |\n| [`codepoint-widths`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L306) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string; sparse array | `\",\"` |\n| [`command-alias`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L210) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string; sparse array | `\",\"` |\n| [`copy-command`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L225) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string | — |\n| [`copy-mode-current-line-number-style`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1208) | 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`copy-mode-current-match-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L818) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`copy-mode-line-number-style`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1217) | 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`copy-mode-line-numbers`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1226) | 3.7, 3.7a, 3.7b, 3.7c | window | `off`, `default`, `absolute`, `relative`, `hybrid` | — |\n| [`copy-mode-mark-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L827) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`copy-mode-match-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L809) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`copy-mode-position-format`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1128) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | string | — |\n| [`copy-mode-position-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1140) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`copy-mode-selection-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1149) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`cursor-colour`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L245) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | colour | — |\n| [`cursor-style`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L252) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | `default`, `blinking-block`, `block`, `blinking-underline`, `underline`, `blinking-bar`, `bar` | — |\n| [`default-client-command`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L338) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | command | — |\n| [`default-command`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L382) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`default-shell`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L390) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`default-size`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L397) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`default-terminal`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L233) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string | — |\n| [`destroy-unattached`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L405) | 3.2a, 3.3, 3.3a | session | flag | — |\n| [`destroy-unattached`](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c#L488) | 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `off`, `on`, `keep-last`, `keep-group` | — |\n| [`detach-on-destroy`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L413) | 3.2a, 3.3, 3.3a | session | `off`, `on`, `no-detached` | — |\n| [`detach-on-destroy`](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c#L497) | 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `off`, `on`, `no-detached`, `previous`, `next` | — |\n| [`display-panes-active-colour`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L422) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | colour | — |\n| [`display-panes-colour`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L429) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | colour | — |\n| [`display-panes-time`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L436) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 1..2147483647 | — |\n| [`display-time`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L446) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..2147483647 | — |\n| [`editor`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L240) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string | — |\n| [`escape-time`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L247) | 3.2a | server | 0..2147483647 | — |\n| [`escape-time`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L274) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | 0..2147483647 | — |\n| [`exit-empty`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L256) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | flag | — |\n| [`exit-unattached`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L263) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | flag | — |\n| [`extended-keys`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L271) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | `off`, `on`, `always` | — |\n| [`extended-keys-format`](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c#L320) | 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | `csi-u`, `xterm` | — |\n| [`fill-character`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L885) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`focus-events`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L280) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | flag | — |\n| [`focus-follows-mouse`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L670) | 3.7, 3.7a, 3.7b, 3.7c | session | flag | — |\n| [`get-clipboard`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L414) | 3.7, 3.7a, 3.7b, 3.7c | server | `off`, `buffer`, `request`, `both` | — |\n| [`history-file`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L287) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string | — |\n| [`history-limit`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L456) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..2147483647 | — |\n| [`initial-repeat-time`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L664) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..2000000 | — |\n| [`input-buffer-size`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L416) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | 1048576..4294967295 | — |\n| [`key-table`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L468) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`lock-after-time`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L476) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..2147483647 | — |\n| [`lock-command`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L486) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`main-pane-height`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L836) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`main-pane-width`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L844) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`menu-border-lines`](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c#L359) | 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `single`, `double`, `heavy`, `simple`, `rounded`, `padded`, `none` | — |\n| [`menu-border-style`](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c#L350) | 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`menu-selected-style`](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c#L341) | 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`menu-style`](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c#L332) | 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`message-command-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L493) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | style string | — |\n| [`message-format`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L736) | 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`message-limit`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L295) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | 0..2147483647 | — |\n| [`message-line`](https://github.com/tmux/tmux/blob/9ae69c3795ab5ef6b4d760f6398cd9281151f632/options-table.c#L587) | 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `0`, `1`, `2`, `3`, `4` | — |\n| [`message-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L503) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | style string | — |\n| [`mode-keys`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L852) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `emacs`, `vi` | — |\n| [`mode-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L860) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`monitor-activity`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L869) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | flag | — |\n| [`monitor-bell`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L876) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | flag | — |\n| [`monitor-silence`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L883) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | 0..2147483647 | — |\n| [`mouse`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L512) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | flag | — |\n| [`other-pane-height`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L894) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`other-pane-width`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L902) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`pane-active-border-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L910) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b | window | style string | — |\n| [`pane-active-border-style`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1315) | 3.7, 3.7a, 3.7b, 3.7c | window, pane | style string | — |\n| [`pane-base-index`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L919) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | 0..65535 | — |\n| [`pane-border-format`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L928) | 3.2a | window | string | — |\n| [`pane-border-format`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L984) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | string | — |\n| [`pane-border-indicators`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L992) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `off`, `colour`, `arrows`, `both` | — |\n| [`pane-border-lines`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L936) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a | window | `single`, `double`, `heavy`, `simple`, `number` | — |\n| [`pane-border-lines`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1274) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `single`, `double`, `heavy`, `simple`, `number`, `spaces` | — |\n| [`pane-border-status`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L944) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `off`, `top`, `bottom` | — |\n| [`pane-border-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L952) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b | window | style string | — |\n| [`pane-border-style`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1374) | 3.7, 3.7a, 3.7b, 3.7c | window, pane | style string | — |\n| [`pane-colours`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1027) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | colour; sparse array | `\" ,\"` |\n| [`pane-scrollbars`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1308) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `off`, `modal`, `on` | — |\n| [`pane-scrollbars-position`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1325) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `right`, `left` | — |\n| [`pane-scrollbars-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1316) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | style string | — |\n| [`pane-status-current-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L924) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`pane-status-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L933) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`popup-border-lines`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1053) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `single`, `double`, `heavy`, `simple`, `rounded`, `padded`, `none` | — |\n| [`popup-border-style`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1044) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`popup-style`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1035) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`prefix`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L521) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | key | — |\n| [`prefix-timeout`](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c#L388) | 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | 0..2147483647 | — |\n| [`prefix2`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L528) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | key | — |\n| [`prompt-command-cursor-style`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L997) | 3.7, 3.7a, 3.7b, 3.7c | session | `default`, `blinking-block`, `block`, `blinking-underline`, `underline`, `blinking-bar`, `bar` | — |\n| [`prompt-cursor-colour`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L943) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | colour | — |\n| [`prompt-cursor-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L950) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `default`, `blinking-block`, `block`, `blinking-underline`, `underline`, `blinking-bar`, `bar` | — |\n| [`prompt-history-limit`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L332) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | 0..2147483647 | — |\n| [`remain-on-exit`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L961) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b | window, pane | `off`, `on`, `failed` | — |\n| [`remain-on-exit`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1443) | 3.7, 3.7a, 3.7b, 3.7c | window, pane | `off`, `on`, `failed`, `key` | — |\n| [`remain-on-exit-format`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1071) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | string | — |\n| [`renumber-windows`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L535) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | flag | — |\n| [`repeat-time`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L543) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a | session | 0..32767 | — |\n| [`repeat-time`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L759) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..2000000 | — |\n| [`scroll-on-clear`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1084) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | flag | — |\n| [`session-status-current-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L958) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`session-status-style`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L967) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`set-clipboard`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L304) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | `off`, `external`, `on` | — |\n| [`set-titles`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L554) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | flag | — |\n| [`set-titles-string`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L561) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`silence-action`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L568) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `none`, `any`, `current`, `other` | — |\n| [`status`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L576) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `off`, `on`, `2`, `3`, `4`, `5` | — |\n| [`status-bg`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L584) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | colour | — |\n| [`status-fg`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L592) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | colour | — |\n| [`status-format`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L600) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string; sparse array | `\" ,\"` |\n| [`status-interval`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L612) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..2147483647 | — |\n| [`status-justify`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L622) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `left`, `centre`, `right`, `absolute-centre` | — |\n| [`status-keys`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L630) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `emacs`, `vi` | — |\n| [`status-left`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L638) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`status-left-length`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L645) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..32767 | — |\n| [`status-left-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L654) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | style string | — |\n| [`status-position`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L663) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `top`, `bottom` | — |\n| [`status-right`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L671) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`status-right-length`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L681) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | 0..32767 | — |\n| [`status-right-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L690) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | style string | — |\n| [`status-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L699) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | style string | — |\n| [`synchronize-panes`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L970) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | flag | — |\n| [`terminal-features`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L323) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string; sparse array | `\",\"` |\n| [`terminal-overrides`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L314) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string; sparse array | `\",\"` |\n| [`tiled-layout-max-columns`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1397) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | 0..65535 | — |\n| [`tree-mode-preview-format`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1491) | 3.7, 3.7a, 3.7b, 3.7c | window, pane | string | — |\n| [`tree-mode-preview-style`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1500) | 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`update-environment`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L708) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string; sparse array | `\" ,\"` |\n| [`user-keys`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L334) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | string; sparse array | `\",\"` |\n| [`variation-selector-always-wide`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L532) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | server | flag | — |\n| [`visual-activity`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L718) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `off`, `on`, `both` | — |\n| [`visual-bell`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L727) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `off`, `on`, `both` | — |\n| [`visual-silence`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L736) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | `off`, `on`, `both` | — |\n| [`window-active-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L977) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | style string | — |\n| [`window-pane-current-status-format`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1522) | 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`window-pane-status-format`](https://github.com/tmux/tmux/blob/81f88f8517c9fc5371b56cf117530c6b477c96ac/options-table.c#L1529) | 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`window-size`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L986) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | `largest`, `smallest`, `manual`, `latest` | — |\n| [`window-status-activity-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1007) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`window-status-bell-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1016) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`window-status-current-format`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1025) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`window-status-current-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1032) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`window-status-format`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1041) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`window-status-last-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1049) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`window-status-separator`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1058) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | string | — |\n| [`window-status-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1065) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | style string | — |\n| [`window-style`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L998) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | style string | — |\n| [`word-separators`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L745) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | string | — |\n| [`wrap-search`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1075) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | flag | — |\n| [`xterm-keys`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1083) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | flag | — |\n\n## Hooks\n\n| Name | Releases | Scope | Value | Array separator |\n| --- | --- | --- | --- | --- |\n| [`after-bind-key`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1092) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-capture-pane`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1093) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-copy-mode`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1094) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-display-message`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1095) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-display-panes`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1096) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-kill-pane`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1097) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-list-buffers`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1098) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-list-clients`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1099) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-list-keys`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1100) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-list-panes`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1101) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-list-sessions`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1102) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-list-windows`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1103) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-load-buffer`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1104) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-lock-server`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1105) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-new-session`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1106) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-new-window`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1107) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-paste-buffer`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1108) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-pipe-pane`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1109) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-queue`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1110) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-refresh-client`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1111) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-rename-session`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1112) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-rename-window`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1113) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-resize-pane`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1114) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-resize-window`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1115) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-save-buffer`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1116) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-select-layout`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1117) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-select-pane`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1118) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-select-window`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1119) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-send-keys`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1120) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-set-buffer`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1121) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-set-environment`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1122) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-set-hook`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1123) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-set-option`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1124) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-show-environment`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1125) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-show-messages`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1126) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-show-options`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1127) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-split-window`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1128) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`after-unbind-key`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1129) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`alert-activity`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1130) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`alert-bell`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1131) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`alert-silence`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1132) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-active`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1255) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-attached`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1133) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-dark-theme`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1571) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-detached`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1134) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-focus-in`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1258) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-focus-out`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1259) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-light-theme`](https://github.com/tmux/tmux/blob/0dac7fe434d029a4f0b819cba8eb7963df291990/options-table.c#L1570) | 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-resized`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1135) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`client-session-changed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1136) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`command-error`](https://github.com/tmux/tmux/blob/ac44566c9c7e3e94d23be6def4c7ae83472543f5/options-table.c#L1350) | 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`pane-died`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1137) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | command; sparse array | empty |\n| [`pane-exited`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1138) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | command; sparse array | empty |\n| [`pane-focus-in`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1139) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | command; sparse array | empty |\n| [`pane-focus-out`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1140) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | command; sparse array | empty |\n| [`pane-mode-changed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1141) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | command; sparse array | empty |\n| [`pane-set-clipboard`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1142) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | command; sparse array | empty |\n| [`pane-title-changed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1143) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window, pane | command; sparse array | empty |\n| [`session-closed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1144) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`session-created`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1145) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`session-renamed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1146) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`session-window-changed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1147) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`window-layout-changed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1148) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | command; sparse array | empty |\n| [`window-linked`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1149) | 3.2a | window | command; sparse array | empty |\n| [`window-linked`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1274) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n| [`window-pane-changed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1150) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | command; sparse array | empty |\n| [`window-renamed`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1151) | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | command; sparse array | empty |\n| [`window-resized`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1277) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | window | command; sparse array | empty |\n| [`window-unlinked`](https://github.com/tmux/tmux/blob/3b929f332aafa7f1080eacc31feb11ffbb1d1841/options-table.c#L1152) | 3.2a | window | command; sparse array | empty |\n| [`window-unlinked`](https://github.com/tmux/tmux/blob/87fe00e8b44901240fc22d7120c1b31e4331f6f5/options-table.c#L1278) | 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c | session | command; sparse array | empty |\n"
+    },
+    {
+      "path": "docs/compatibility.md",
+      "content": "# Compatibility targets\n\nThe Lua port is under development. The following versions define required\nacceptance tests; they are not a published support promise. A source declaration,\nsuccessful import, or sibling-port result does not establish live compatibility.\n\n| Component | Required versions |\n| --- | --- |\n| PUC Lua | 5.1.5, 5.2.4, 5.3.6, 5.4.9, 5.5.1 |\n| LuaJIT | v2.1 at c6ffc141a8762b41703f9287d63d93622a13dd8f |\n| Standalone adapter | luv 1.52.1-0 built for each runtime ABI |\n| Neovim | 0.10.0, 0.10.4, 0.11.7, 0.12.5 |\n| tmux | 3.2a, 3.3, 3.3a, 3.4, 3.5, 3.5a, 3.6, 3.6a, 3.6b, 3.7, 3.7a, 3.7b, 3.7c |\n| Platforms | Linux x86_64, macOS arm64; WSL2 recorded separately |\n\nPure-core tests run once per runtime/platform. Standalone and embedded live\ntests cover floor/current tmux for each runtime or host. The full tmux sweep\nuses PUC Lua 5.5.1 and current Neovim. Consumer imports and pure validation cover\neach runtime; floor/current combinations also run interoperability and workspace\nfailure tests. Client/daemon version mismatches must report protocol failures\ntruthfully instead of inferring daemon capabilities from the client executable.\n\nmacOS x86_64 and native Windows transport are outside the initial platform\nmatrix. Local tmux 3.7d and 3.8-rc results are diagnostic evidence and cannot\nreplace released-version checks. Neovim's LuaJIT results do not prove stock\nPUC Lua 5.1 yield behavior. A Neovim build using PUC Lua is a separate host gate.\n\nNamed buffer deletion requires tmux 3.4 or later. The typed API refuses older\nreleases because a missing target can delete another buffer. The older-release\ndeletion parity requirement remains open; see [buffers](buffers.md).\n\nExact operating-system images, binary hashes, compiler and module ABI identities\nbelong with each result. Missing and skipped cells remain unverified. No complete\nproduct compatibility cell has passed yet.\n\nCurrent local implementation evidence comes from Ubuntu 24.04 under WSL2\non x86_64. Record it in the WSL2 lane; it does not close the native Linux or\nmacOS gates. Selected PUC, LuaJIT, Neovim and tmux foundation tests have passed\nthere while the complete product is still being implemented.\n\nThe [CI workflow](../.github/workflows/ci.yml) covers Linux unit runtimes,\nfloor/current outer gates and the released-tmux integration sweep. Its\n[setup and coverage](../.github/CONTRIBUTING.md#github-actions) use the same\nlocal gate commands. A passing run establishes those implemented checks at\nits tested revision; macOS, additional host/runtime combinations and\nunfinished product requirements remain open.\n\nVersion evidence comes from [Lua's version history](https://www.lua.org/versions.html),\n[LuaJIT's release policy](https://luajit.org/status.html), the\n[luv release](https://github.com/luvit/luv/releases/tag/1.52.1-0),\n[Neovim's Lua contract](https://neovim.io/doc/user/lua/#lua-compat), and\n[tmux releases](https://github.com/tmux/tmux/releases).\n"
+    }
+  ]
+}
diff --git a/site/src/data/port-guides/ruby.json b/site/src/data/port-guides/ruby.json
new file mode 100644
index 00000000..b461733b
--- /dev/null
+++ b/site/src/data/port-guides/ruby.json
@@ -0,0 +1,40 @@
+{
+  "source": {
+    "repository": "libtmux/libtmux-ruby",
+    "revision": "e3815d2b35a6c663f20769231e1d22b565f87038"
+  },
+  "guides": [
+    {
+      "path": "README.md",
+      "content": "# libtmux for Ruby\n\nCreate tmux sessions, split windows, send input, and capture pane output from\nRuby. Read server state into a snapshot, then query it with `where`, `select`,\nand the rest of `Enumerable`.\n\n[Quick start](#quick-start) · [Queries](#query-a-snapshot) · [Gems](#gems) ·\n[Guide](docs/index.md) · [API reference](docs/reference/api.md) ·\n[Recipes](docs/recipes.md)\n\n**Alpha.** APIs may change between releases. See the\n[initial alpha notes](CHANGELOG.md) and [release guide](docs/releasing.md).\n\n## Install\n\nInstall the core prerelease from RubyGems:\n\n```console\n$ gem install libtmux --pre\n```\n\nThe [companion gems](#gems) install separately; use `--pre` for their alpha\nversions too.\n\n## Install from source\n\nUse the Ruby pinned in [.tool-versions](.tool-versions) and have `tmux` on your\n`PATH`. From this checkout, install the development bundle:\n\n```console\n$ mise install\n```\n\n```console\n$ mise exec -- bundle config set --local path vendor/bundle\n```\n\n```console\n$ mise exec -- bundle install\n```\n\nThe gemspecs declare Ruby 3.3+. The\n[compatibility workflow](https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml)\ntests Ruby 3.3, 3.4, and 4.0 with tmux 3.2a–3.7c on Linux and macOS. Check the\nresults for your revision before relying on a particular combination.\n\n## Quick start\n\nCreate a session and split its `logs` window. `Server.start` owns a private\ntmux server and closes it when the block exits. The snapshot remains readable\nafterward.\n\n<!-- example: quickstart/main -->\n```ruby\nrequire \"libtmux\"\n\nsnapshot = LibTmux::Server.start do |server|\n  session = server.new_session(name: \"work\", window_name: \"main\", command: [\"/bin/cat\"])\n  window = session.new_window(name: \"logs\", command: [\"/bin/cat\"])\n  window.split(direction: :horizontal, size: \"40%\", command: [\"/bin/cat\"])\n\n  server.snapshot\nend\n\nsnapshot.windows.each do |window|\n  puts \"#{window.name}: #{window.panes.map(&:id).join(', ')}\"\nend\n```\n<!-- /example -->\n\nRun the [complete example](examples/quickstart.rb):\n\n```console\n$ mise exec -- bundle exec ruby examples/quickstart.rb\n```\n\nOutput:\n\n```text\nmain: %0\nlogs: %1, %2\n```\n\nPane commands take argument arrays. To use an existing server, open an explicit\nendpoint with `LibTmux::Server.open(socket_path: ...)`; closing that binding\nleaves the daemon running. See [ownership and errors](docs/ownership-errors.md).\n\n## Query a snapshot\n\nContinue with the snapshot above. `where` accepts criteria as data; `select`\naccepts a Ruby block. These queries make no tmux calls.\n\n<!-- example: quickstart/queries -->\n```ruby\npanes = snapshot.panes\nactive_ids = panes.where(active: true).map(&:id)\nwide_panes = panes.select { |pane| pane.width >= 40 }\npanes_by_window = panes.group_by { |pane| pane.window.name }\n\nlogs = snapshot.windows.one(name: \"logs\")\nmissing = snapshot.windows.one_or_nil(name: \"missing\")\n```\n<!-- /example -->\n\n`one` raises `NoMatchError` or `MultipleMatchesError` unless exactly one record\nmatches. `one_or_nil` returns `nil` for no match and still rejects duplicates.\nBoth errors live under `LibTmux`.\n\nSelections retain captured membership. Call `server.snapshot` again while the\nserver is open to read later changes. The [field catalog](docs/reference/fields.md)\nlists query fields and wire names; the [list/filter recipe](examples/list_filter.rb)\nalso covers exact matches and queries after close.\n\n## Gems\n\nStart with `libtmux`. Add the companion for your caller:\n\n| Gem | Require | Use it for |\n| --- | --- | --- |\n| [libtmux](gems/libtmux/README.md) | `libtmux` | Blocking scripts, snapshots, and control connections |\n| [libtmux-async](gems/libtmux-async/README.md) | `libtmux/async` | Concurrent commands and bounded streams in Async tasks |\n| [libtmux-mcp](gems/libtmux-mcp/README.md) | `libtmux/mcp` | An MCP server with explicit endpoints and tool policy |\n| [libtmux-workspace](gems/libtmux-workspace/README.md) | `libtmux/workspace` | YAML/JSON workspace plans and a CLI to apply them |\n\nRequiring a gem starts no tmux process, scheduler, or protocol server.\n[Execution modes](docs/modes.md) explains blocking calls, Async tasks, and\ncontrol subscriptions. Tracked MCP captures, waits, and authored runs require\ntmux 3.3+ and native process identity; see the [MCP guide](gems/libtmux-mcp/README.md).\nWorkspace client-switching semantics are in the\n[workspace guide](gems/libtmux-workspace/README.md).\n\nTo use the core outside this checkout, build the artifacts:\n\n```console\n$ mise exec -- bundle exec rake build\n```\n\nInstall into the Ruby environment that will run your application. The core's\nruntime dependencies must already be installed for this local-only command:\n\n```console\n$ gem install \\\n    --local \\\n    --no-document \\\n    pkg/libtmux-0.1.0.alpha.1.gem\n```\n\nCompanion gems need their declared runtime dependencies too. The\n[packaging check](.github/CONTRIBUTING.md#checks) verifies each gem in an\nisolated installation and runs the recipes outside the checkout.\n\n## More examples and reference\n\n- [Send text and capture output](examples/layout_io.rb): split panes, wait for\n  output events, and round-trip binary buffers.\n- [Work with linked windows](examples/window_links.rb): address one window at\n  several session indexes.\n- [Capture concurrently](examples/async_cancel.rb): read panes while another\n  request waits, then cancel it.\n- [Load a workspace](examples/workspace_apply.rb): parse a configuration, plan,\n  and apply it.\n- [All recipes](docs/recipes.md): cancellation, control streams, command groups,\n  and MCP.\n- [API reference](docs/reference/api.md): public methods, source links, and\n  behavioral contracts. RBS declarations ship with each gem; selected installed\n  calls are checked, without a whole-program typing guarantee.\n- [Benchmarks](docs/benchmark.md): workloads, measurements, and their limits.\n\nSee [Contributing](.github/CONTRIBUTING.md) for setup and checks.\n[MIT license](LICENSE).\n"
+    },
+    {
+      "path": "docs/modes.md",
+      "content": "# Execution modes\n\n| Mode | Wait and ownership | Result evidence |\n| --- | --- | --- |\n| Core command | Calling thread blocks; server binding owns each client and its pipes | `CommandResult` has binary stdout/stderr and final client status |\n| Captured query | Snapshot acquisition performs explicit I/O; `Selection` filtering is local | Stable captured membership with acquisition interval and coverage |\n| Command group | One client submits an ordered, nontransactional group | Aggregate final status; individual steps remain `unknown` |\n| Core control | One owned reader thread drains the connection; each subscriber has limits | Guarded blocks between boundaries; hooks can share the interval |\n| Async | Caller supplies an Async parent task; pipe I/O yields on its scheduler | Same command evidence, with bounded request admission and cancellation |\n| MCP | Caller supplies transport streams, Async scope and tool policy | Versioned protocol envelopes and structured tool responses |\n| Workspace | Parsing and planning are inert; apply performs ordered commands | Created-reference ledger, observed effects and explicit uncertainty |\n\nUse `Server.open(socket_path: ...)` to borrow a daemon through a pinned\nbinding. `Server.start` creates an owned daemon on a unique socket and closes\nit with the block. No API in these recipes chooses the default server.\n\n`CommandResult#success?` means the client exited successfully. Sending input\ndoes not establish shell completion. A `GuardedReply` has no `success?`:\n`%end` terminates a guard, while WAIT commands, aliases and hooks can change\nwhat finishes when. Its `boundary_window` attribution is deliberately weaker\nthan per-command ownership.\n\nConcurrent control calls pipeline complete wire requests on one connection.\nThe writer can submit a later request while an earlier reply waits; the reader\nassigns boundaries in the same order. Admission limits include all pending\nand completed but unconsumed requests. Cancellation after any request bytes\nare written closes the connection: other written requests have\n`possibly_sent` delivery, and requests with no written bytes have `not_sent`.\nNo uncertain request is replayed. Sequential calls still wait for each reply.\n\nReliable control subscriptions raise `SubscriptionOverflow` when they cannot\nretain the stream. Tail subscriptions emit a gap containing lost sequence\nand byte evidence. Neither mode blocks the command reader behind a slow\nconsumer. Limits apply to connection-owned buffers; callers own the replies\nthey retain after return.\n\nCaptured queries evaluate the whole criteria tree before selecting rows,\nincluding inactive OR branches. Explain methods perform no I/O. Current\nsource plans use explicit capture and local evaluation; unsupported required\npushdown fails rather than silently changing semantics.\n\nSee [the recipes](recipes.md) for event-based WAIT release, cancellation,\noverflow and group-failure examples. No throughput comparison is claimed.\n"
+    },
+    {
+      "path": "docs/ownership-errors.md",
+      "content": "# Ownership and errors\n\nAn entity reference contains a binding identity, kind and tmux-assigned ID.\nWindow links also retain session and index context. A snapshot can describe\none window at several indexes without creating several window identities.\nNames are query values, not substitutes for stable command targets.\n\nA borrowed binding retains its private socket route. Replacing the public\nsocket does not authorize following a new server. Closing the binding retires\nowned clients and pipes and preserves the borrowed daemon. A server started\nwith `Server.start` owns its daemon and temporary directory as well. Handles,\nAsync tasks and subscriptions cannot be transferred to another process or\nscheduler as if their ownership were unchanged.\n\n| Failure or empty value | Meaning |\n| --- | --- |\n| Empty `Selection` / `one_or_nil` returns `nil` | A valid complete local selection has no matching record |\n| `NoMatchError` / `MultipleMatchesError` | `one` cannot establish exactly one match |\n| `InvalidFilterError` / `FieldDecodeError` | Criteria or wire values do not satisfy the declared schema |\n| `IncompleteSnapshotError` | Required coverage is unavailable; do not infer absence |\n| `TargetNotFoundError` | The guarded target no longer matches its identity/context |\n| `Cancelled` / `DeadlineExceeded` | The requested wait ended; delivery evidence determines possible effects |\n| `SubscriptionOverflow` / gap event | A bounded stream cannot establish uninterrupted delivery |\n| `Workspace::ApplyError` | Inspect its immutable result ledger before deciding whether to compensate |\n\nOperation errors report a phase and delivery evidence: `not_sent`,\n`possibly_sent`, or `observed`. An observed nonzero exit still needs its\ncommand result. Cleanup diagnostics accompany failures; cleanup failure is\nnot a successful close. A cancelled mutating request can already have effects.\nA timed-out WAIT lock request can still acquire its queued remote lock after\na later unlock; retiring the client does not roll back tmux's command queue.\n\nClient cancellation sends TERM, then KILL if exit is still unobserved, and\nuses the remaining cleanup deadline to reap the owned child. There is no\nscheduled grace period for a TERM handler. This policy applies to owned\ncommand clients; cancelling their requests does not terminate borrowed panes\nor daemons.\n\nCreate `LibTmux::Cancellation.new` for blocking requests and pass it as `cancel:`.\nCalling `cancel` from another thread wakes current users of that token and makes\n`cancelled?` true permanently; later requests with the same token refuse before\ndispatch. A token can cancel several requests. It owns a pipe, starts no thread,\nand must remain open until every request using it has returned. Join those\ncallers before calling `close`; closing a token does not join them. Both methods\nare idempotent and their return values are unspecified. `reader` belongs to the\ntoken: do not consume its bytes or close it separately. After a fork, a child\nmay close its inherited descriptors but cannot query or cancel the parent's token.\nThe [plain-Ruby example](../examples/cancel.rb) proves wakeup, delivery evidence\nand client reaping without sleeps. Async tasks can instead use `Task#cancel` as\nshown in the [Async example](../examples/async_cancel.rb).\n\nWorkspace compensation is explicit. It removes only a positively created\nsession whose current windows and panes all belong to the creation ledger,\nchecked in the same tmux command turn. A borrowed window or pane moved into\nthat session prevents destructive compensation. Arbitrary shell effects\ncannot be rolled back, and an unacknowledged creation is never guessed by name.\n\nParsing errors and ordinary inspection redact payloads. Explicit results,\ncaptures, plans and canonical exports contain the requested data, including\ncommands or normalized paths; callers control their storage and display.\n\nSee [execution modes](modes.md) and [workspace details](../gems/libtmux-workspace/README.md).\n"
+    },
+    {
+      "path": "docs/recipes.md",
+      "content": "# Executable recipes\n\nEvery linked program loads installed gems, starts an isolated server, asserts\nits result and verifies owned-daemon cleanup. The shared\n[support module](../examples/support.rb) supplies assertions and the cleanup\nwrapper. No program adds checkout paths to Ruby's load path.\n\nRun a program from the repository after installing its required local gems:\n\n```console\n$ ruby examples/window_links.rb\n```\n\nThe artifact suite copies programs outside the checkout and runs them against\neach gem's isolated dependency closure. [The manifest](../examples/manifest.json)\nowns file discovery and the source regions used below. `scripts/examples\n--check` rejects an unlisted program or a changed excerpt.\n\n## Captured queries\n\n[Complete list/filter/exact-one program](../examples/list_filter.rb). A fresh\nwindow does not alter an existing capture; local filtering still works after\nthe binding closes.\n\n<!-- example: list_filter/main -->\n```ruby\nsession = server.new_session(name: \"capture\", command: [\"/bin/cat\"])\nsession.new_window(name: \"second\", command: [\"/bin/cat\"])\nsnapshot = server.snapshot\npanes = snapshot.panes\nfirst = panes.one(id: panes.first.id)\nsession.new_window(name: \"later\", command: [\"/bin/cat\"])\nExample.check(panes.size == 2, \"captured membership changed\")\nExample.check(panes.where(id: first.id).one.ref == first.ref, \"wrong exact match\")\nExample.raises(LibTmux::MultipleMatchesError) { panes.one }\nExample.check(panes.one_or_nil(id: \"%4294967294\").nil?, \"missing pane was invented\")\n```\n<!-- /example -->\n\n## Layout and bytes\n\n[Complete layout/capture/send program](../examples/layout_io.rb). A control\noutput event establishes that the literal input has reached the pane before\ncapture. Binary buffers round-trip without text decoding.\n\n<!-- example: layout_io/main -->\n```ruby\nreceipt = server.new_session(name: \"layout\", command: [\"/bin/cat\"], receipt: true)\npane = receipt.pane\nsecond = pane.split(direction: :horizontal, size: \"40%\", command: [\"/bin/cat\"])\nreceipt.window.select_layout(\"tiled\")\nExample.check(receipt.window.list_panes.map(&:id).sort == [pane.id, second.id].sort, \"assigned pane IDs differ\")\nserver.open_control(session: receipt.entity.ref) do |control|\n  control.exchange(\"display-message -p ready\", timeout: 0.5)\n  output = control.subscribe(pane_id: pane.id, max_bytes: 8192, max_events: 32)\n  literal = \"literal; #{'#{pane_id}'} $HOME\"\n  pane.send_text(literal)\n  bytes = \"\".b\n  bytes << output.next(timeout: 0.5).data until bytes.include?(literal)\n  Example.check(pane.capture.stdout.include?(literal), \"capture lost literal input\")\nend\npayload = \"NUL\\0\\xff\\n\".b\nserver.write_buffer(name: \"bytes\", data: payload)\nExample.check(server.read_buffer(\"bytes\").stdout == payload, \"buffer bytes changed\")\n```\n<!-- /example -->\n\n## One window at three indexes\n\n[Complete window-link program](../examples/window_links.rb). Window identity\nand selection context remain distinct.\n\n<!-- example: window_links/main -->\n```ruby\nsession = server.new_session(name: \"links\", command: [\"/bin/cat\"])\nwindow = session.list_windows.fetch(0)\nsession.link_window(window.ref, index: 4)\nsession.link_window(window.ref, index: 9)\nlinks = session.list_window_links\nExample.check(links.map(&:index) == [0, 4, 9], \"link indexes differ\")\nExample.check(links.map { |link| link.window.ref }.uniq == [window.ref], \"window identity split\")\nExample.check(links.map(&:ref).uniq.length == 3, \"link contexts collapsed\")\nlinks.find { |link| link.index == 9 }.select\nExample.check(session.display('#{window_index}').text == \"9\\n\", \"wrong current link\")\n```\n<!-- /example -->\n\n## Blocking request cancellation\n\n[Complete plain-Ruby cancellation program](../examples/cancel.rb). A tmux event\nproves dispatch before another thread cancels the blocked client. The program\njoins the caller, checks client reaping and closes the token's owned pipe.\n\n<!-- example: cancel/main -->\n```ruby\ncancellation = LibTmux::Cancellation.new\nwaiting = nil\nbegin\n  waiting = Thread.new do\n    server.run([\"wait-for\", \"-S\", \"ready\", \";\", \"wait-for\", \"held\"],\n      timeout: 0.5, cancel: cancellation)\n  rescue LibTmux::Cancelled => error\n    error\n  end\n  server.wait_for(\"ready\", timeout: 0.5)\n  cancellation.cancel\n  failure = waiting.value\n  Example.check(failure.is_a?(LibTmux::Cancelled), \"cancellation lost\")\n  Example.check(failure.delivery == :possibly_sent, \"dispatched wait claimed no effects\")\n  Example.raises(Errno::ECHILD) { Process.waitpid(failure.pid, Process::WNOHANG) }\n  Example.check(server.diagnostics.fetch(:admitted_requests).zero?, \"client remains admitted\")\nensure\n  begin\n    cancellation.cancel\n    waiting&.join\n  ensure\n    cancellation.close\n  end\nend\n```\n<!-- /example -->\n\n## Async capture and cancellation\n\n[Complete Async program](../examples/async_cancel.rb). A second task captures\nwhile another tmux client waits; cancellation retires that client's process.\n\n<!-- example: async_cancel/main -->\n```ruby\nAsync do |parent|\n  LibTmux::Async.open(parent: parent, server: server) do |scope|\n    waiting = parent.async do\n      scope.server.run([\"wait-for\", \"-S\", \"ready\", \";\", \"wait-for\", \"held\"], timeout: 0.5)\n    rescue LibTmux::Cancelled => error\n      error\n    end\n    scope.server.wait_for(\"ready\", timeout: 0.5)\n    Example.check(scope.diagnostics.fetch(:active_process_slots) == 1, \"waiting client lost its slot\")\n    captures = scope.map(scope.server.list_panes.map(&:ref), concurrency: 2) do |ref|\n      scope.server.pane(ref).capture\n    end\n    Example.check(captures.all?(&:success?), \"sibling captures stalled\")\n    waiting.cancel\n    failure = waiting.wait\n    Example.check(failure.is_a?(LibTmux::Cancelled), \"cancellation lost\")\n    Example.check(failure.delivery == :possibly_sent, \"cancelled dispatch claimed no effects\")\n    Example.raises(Errno::ECHILD) { Process.waitpid(failure.pid, Process::WNOHANG) }\n    Example.check(scope.server.diagnostics.fetch(:admitted_requests).zero?, \"cancelled client remains admitted\")\n  end\nend.wait\n```\n<!-- /example -->\n\n## Control overflow\n\n[Complete control program](../examples/control_overflow.rb). A slow reliable\nsubscriber fails explicitly; a tail subscriber reports a gap and replies\ncontinue to drain.\n\n<!-- example: control_overflow/main -->\n```ruby\nserver.open_control(session: session.ref) do |control|\n  control.exchange(\"display-message -p ready\", timeout: 0.5)\n  reliable = control.subscribe(max_events: 1, max_bytes: 1024)\n  tail = control.subscribe(mode: :tail, max_events: 1, max_bytes: 1024)\n  3.times { |index| window.rename(\"event#{index}\") }\n  reply = control.exchange(\"display-message -p alive\", timeout: 0.5)\n  Example.check(reply.blocks.last.body == \"alive\\n\", \"slow reader blocked commands\")\n  Example.check(reply.attribution == :boundary_window, \"reply overclaims attribution\")\n  Example.check(reliable.diagnostics.fetch(:overflowed), \"overflow is missing from diagnostics\")\n  Example.check(control.diagnostics.fetch(:retained_reply_bytes).zero?, \"consumed reply remains retained\")\n  reliable.next(timeout: 0.5)\n  Example.raises(LibTmux::SubscriptionOverflow) { reliable.next(timeout: 0.5) }\n  gap = tail.next(timeout: 0.5)\n  Example.check(gap.kind == :gap && gap.dropped_bytes.positive?, \"tail hid lost bytes\")\nend\n```\n<!-- /example -->\n\n## Failure inside a group\n\n[Complete group program](../examples/failed_group.rb). The first mutation\nsurvives a later failure. A separate read establishes the missing later effect;\nthe group result does not invent statuses for its members.\n\n<!-- example: failed_group/main -->\n```ruby\ngroup = server.run_group([\n  [\"set-option\", \"-g\", \"@before\", \"retained\"],\n  [\"select-pane\", \"-t\", \"%4294967294\"],\n  [\"set-option\", \"-g\", \"@after\", \"not-executed\"]\n])\nExample.check(!group.success?, \"failing group succeeded\")\nExample.check(group.steps.all? { |step| step.fetch(:outcome) == :unknown }, \"invented per-step status\")\nExample.check(server.options(scope: :session).get(\"@before\").raw == \"retained\", \"earlier effect rolled back\")\nExample.check(server.options(scope: :session).list.none? { |option| option.name == \"@after\" }, \"later step executed\")\n```\n<!-- /example -->\n\n## MCP protocol\n\n[Complete MCP program](../examples/mcp_protocol.rb). Real pipe frames exercise\ndiscovery, snapshot reads, default mutation denial and cancellation of an\napplication-owned WAIT method. The custom WAIT method is a transport probe,\nnot part of the advertised tmux tool catalog.\n\n<!-- example: mcp_protocol/main -->\n```ruby\napplication = LibTmux::MCP::Application.new(server: scope.server, endpoint_name: \"example\")\nsdk = application.sdk_server\ninput, client_input = IO.pipe\nclient_output, output = IO.pipe\ntransport = LibTmux::MCP::StdioTransport.new(server: sdk, parent: parent, input: input, output: output)\nrunner = parent.async { transport.run }\n```\n<!-- /example -->\n\nThe installed executable also exercises explicitly enabled create, send,\nclose and authored-run tools. Its complete program creates a zsh pane whose\nstartup file explicitly sources the CLI's mode-0600 enrollment file, waits\nfor the authenticated acknowledgement, and checks binary stderr and native\nexit status. It closes stdin and verifies enrollment cleanup and borrowed\ndaemon survival. An unsupported advertised process backend exercises the\nstructured refusal instead; that is not positive enrollment evidence.\n\n<!-- example: mcp_protocol/cli -->\n```ruby\nexecutable = Gem.bin_path(\"libtmux-mcp\", \"libtmux-mcp\")\nOpen3.popen3(Gem.ruby, \"-W:no-experimental\", executable, \"--socket\", server.endpoint.socket_path,\n  \"--tmux\", Example.executable, \"--endpoint\", \"installed\", \"--enable-tool\", \"tmux_create\", \"--enable-tool\", \"tmux_send\",\n  \"--enable-tool\", \"tmux_close\", \"--enable-tool\", \"tmux_run\", *enrollment_arguments) do |input, output, errors, process|\n  request = lambda do |id, method, params = {}|\n    input.write(JSON.generate({jsonrpc: \"2.0\", id: id, method: method, params: params}) + \"\\n\")\n    Example.check(IO.select([output], nil, nil, id == 1 ? 1.0 : 0.5), \"installed MCP did not return a frame\")\n    response = JSON.parse(output.gets)\n    Example.check(response.fetch(\"id\") == id, \"MCP response identity changed\")\n    response.fetch(\"result\")\n  end\n  request.call(1, \"initialize\", {protocolVersion: \"2025-11-25\", capabilities: {},\n    clientInfo: {name: \"recipe\", version: \"1\"}})\n  input.write(JSON.generate({jsonrpc: \"2.0\", method: \"notifications/initialized\"}) + \"\\n\")\n  names = request.call(2, \"tools/list\").fetch(\"tools\").map { |tool| tool.fetch(\"name\") }\n  Example.check(names.sort == %w[tmux_capabilities tmux_close tmux_create tmux_run tmux_send tmux_snapshot], \"tool policy differs\")\n  created = request.call(3, \"tools/call\", {name: \"tmux_create\", arguments: {\n    kind: \"session\", name: \"via-protocol\", argv: [\"/bin/cat\"]}}).fetch(\"structuredContent\")\n  Example.check(created.fetch(\"ok\"), \"protocol creation failed\")\n  data = created.fetch(\"data\")\n  pane = data.fetch(\"created\").find { |ref| ref.fetch(\"kind\") == \"pane\" }\n  sent = request.call(4, \"tools/call\", {name: \"tmux_send\", arguments: {\n    target: pane, input: {type: \"text\", text: \"literal;\"}}}).fetch(\"structuredContent\")\n  Example.check(sent.fetch(\"data\").fetch(\"completion\") == \"dispatch_only\", \"send claimed shell completion\")\n  target = pane\n  if channel\n    Example.check(File.stat(setup).mode & 0o777 == 0o600, \"enrollment setup permissions differ\")\n    channel.puts(setup)\n    Example.check(IO.select([channel], nil, nil, 0.5) && channel.gets == \"ready\\n\", \"shell enrollment was not acknowledged\")\n    target = pane.merge(\"id\" => shell_pane.id)\n  end\n  script = 'printf \"%s:%s\" \"$EXAMPLE_CONTEXT\" \"$TMUX_PANE\"; printf \"\\\\000\\\\377\" >&2; exit 9'\n  run = request.call(5, \"tools/call\", {name: \"tmux_run\", arguments: {\n    target: target, script: script, stdout_limit: 128, stderr_limit: 2}}).fetch(\"structuredContent\")\n  if channel\n    Example.check(run.fetch(\"ok\"), \"installed authored run failed\")\n    result = run.fetch(\"data\")\n    Example.check(result.fetch(\"stdout\").fetch(\"data\") == \"installed:#{shell_pane.id}\", \"authored shell context differs\")\n    Example.check(result.fetch(\"stderr\") == {\"encoding\" => \"base64\", \"data\" => \"AP8=\", \"bytes\" => 2, \"truncated\" => false}, \"authored bytes differ\")\n    Example.check(result.fetch(\"completion\") == {\"state\" => \"exited\", \"exit_status\" => 9, \"signal\" => nil}, \"native completion differs\")\n    Example.check(result.fetch(\"authorization\").fetch(\"state\") == \"authorized\", \"authorization receipt missing\")\n  else\n    Example.check(run.dig(\"error\", \"code\") == \"unsupported\" && run.dig(\"error\", \"delivery\") == \"not_sent\", \"unsupported enrollment did not refuse\")\n  end\n  closed = request.call(6, \"tools/call\", {name: \"tmux_close\", arguments: {target: data.fetch(\"entity\")}})\n  Example.check(closed.fetch(\"structuredContent\").fetch(\"ok\"), \"protocol close failed\")\n  input.close\n  Example.check(process.join(0.5), \"MCP EOF did not retire its process\")\n  Example.check(process.value.success? && errors.read.empty?, \"MCP executable failed\")\n  Example.check(!File.exist?(setup), \"enrollment setup survived EOF\")\nend\n```\n<!-- /example -->\n\n## Workspace plan, load and failure\n\n[Complete workspace program](../examples/workspace_apply.rb) consumes the\n[checked configuration](../examples/workspace.yaml), applies it, then verifies\npartial failure and guarded compensation when another layout exceeds available\npane space. It also runs installed CLI validation, planning and loading.\n\n<!-- example: workspace_apply/main -->\n```ruby\nworkspace = LibTmux::Workspace.load(File.join(__dir__, \"workspace.yaml\"))\nplan = workspace.plan(snapshot: server.snapshot)\nExample.check(server.list_sessions.size == 1, \"planning changed tmux\")\nresult = plan.apply(server: server)\nExample.check(result.success?, \"workspace apply failed\")\nExample.check(result.effects.any? { |effect| effect.outcome == :dispatch_only }, \"shell dispatch overclaims completion\")\ncrowded = LibTmux::Workspace.parse(JSON.generate({\n  session_name: \"crowded\", windows: [{window_name: \"small\", panes: Array.new(40) { {} }}]\n}), format: :json, base_directory: __dir__)\nerror = Example.raises(LibTmux::Workspace::ApplyError) do\n  crowded.plan.apply(server: server, compensate: true)\nend\nExample.check(!error.result.created_refs.empty?, \"failure lost partial creation ledger\")\nExample.check(error.result.compensation == :completed, \"owned compensation failed\")\nExample.check(server.list_sessions.map(&:ref).include?(borrowed.ref), \"borrowed session was removed\")\n```\n<!-- /example -->\n"
+    },
+    {
+      "path": "gems/libtmux/README.md",
+      "content": "# libtmux\n\nRuby tmux orchestration core. `Server.open` borrows an\nexisting explicit endpoint. Closing it retires owned clients and preserves\nthe daemon; `kill` explicitly terminates the daemon. `Server.start` creates a\nprivate owned foreground daemon whose lifetime ends with its server handle.\nOwned startup uses Linux and Darwin readiness backends. The\n[compatibility workflow](https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml)\nretains exact per-revision platform and version results.\n\nInstall the alpha with `gem install libtmux --pre`, then require `libtmux`.\nImports do not\nstart tmux, a scheduler or an MCP server. See the repository's contribution\nguide for local build and verification commands.\n\nHandles carry immutable refs bound to one open server binding. IDs and refs\nare local readers; `list_*`, `snapshot` and command methods perform explicit\nI/O. Global windows represent unique entities. `WindowLink` retains a session,\nindex and window ID so repeated links stay distinct.\n\nLink selection, unlinking, movement, swapping and display check the complete\nlink identity in the same tmux queue turn as their operation. Configured\ncommand aliases are avoided using unshadowed builtin spellings. Hook waits\nbefore dispatch cannot turn a stale link into its replacement. Concurrent\nrewriting of command aliases is outside this guarantee; applications must\ncoordinate configuration changes.\n\nTyped arguments preserve literal semicolons and distinguish pane text from\nkey names. Pane commands take executable argument arrays. Hook commands,\ndisplay formats, pipe shell commands and `source_file` configuration are\nexplicit executable inputs. `Server.run` remains the raw tmux escape hatch,\nincluding daemon aliases, separators and format semantics.\n\nCreation accepts `cwd:` and a String-to-String `environment:` map. Directories\nresolve from the Ruby caller and are checked before dispatch; concurrent\nfilesystem changes can still trigger tmux's directory fallback. Creation\nreturns tmux-assigned IDs after dispatch, without claiming program readiness\nor a successful program exit. `new_session(window_name:)` names the initial\nwindow; its index can be moved explicitly after creation. `new_window(index:)`\nrefuses an occupied slot. `Pane#split` targets that exact pane, with `size:` as\ncells or a percentage string. Windows and splits retain focus unless\n`focus: true` is requested.\n\nTyped operations accept `timeout:` and `cancel:`. Composed link and copy operations\nshare one deadline across their preflights and final dispatch. Copy-mode\nexit uses `cancel_mode: true`; `cancel:` accepts `LibTmux::Cancellation.new`.\nCall the token's `cancel` from another thread to wake a blocked request, join\nits caller, then `close` the token. See the [plain-Ruby cancellation recipe](../../examples/cancel.rb)\nand [ownership contract](../../docs/ownership-errors.md).\n\n`Options` retains raw bytes, inheritance and sparse array indexes;\n`OptionValue#as` requests a strict conversion. Hook values remain tmux command\nstrings. The stable tmux option listing uses its escaped representation,\nincluding octal bytes; it does not split raw values on line breaks. Option\nnames containing whitespace are currently rejected. Inherited hook listing\nis not implemented and raises explicitly.\n\nIndexed `get` acquires the array and selects locally, so a missing index raises\n`NoMatchError` while a present empty value remains present. Reading an array\nwithout an index raises `MultipleMatchesError` when it has several entries.\nAppend follows tmux's lowest-free-index rule; indexed hooks execute in index\norder. Empty arrays remain distinct from empty String values.\n\nBinary buffers and command results preserve trailing newlines. Capture can\njoin wrapped lines, include attribute escapes, escape nonprintable bytes,\npreserve trailing spaces and trim unused trailing cells. `mode_screen: true`\nreads the mode's backing screen (the copy-mode snapshot, without its UI),\n`alternate: true` reads tmux's saved screen and raises when absent (while an\napplication occupies the alternate screen, this is the saved main screen),\nand `pending: true` reads an incomplete escape sequence. These three selectors\nare mutually exclusive. Mode-screen and trailing-cell flags are checked\nagainst advertised command usage; unsupported requests raise explicitly.\nCopy-mode flags are checked against the connected daemon's advertised command\nusage. Client discovery returns observations. `Server#attach` uses an explicit\ncaller-owned TTY and terminal type, waits for its owned client to exit, and\nrestores the terminal mode. `Server#switch_client(client:, session:)` switches\nan explicit current native client selector to an exact bound session, keeping\nthe session environment. A missing selector fails without fallback. This\noperation does not turn a client observation into an incarnation-safe\nreference; a reconnect matching the selector is eligible at dispatch.\n\nControl connections expose bounded event subscriptions and raw guarded replies.\n`pause_output(pane_id:)` and `resume_output(pane_id:)` return `GuardedReply`;\nthey do not establish that an action took effect. Their gap events identify\n`:pause_requested` or `:resume_requested` when no outside-block native notice\nwas observed, including cancellation after possible dispatch. Native notices\nuse `:pause` and `:resume`. Loss counts are unknown (`dropped_bytes: nil`);\nresume does not replay skipped output. Guarded notification-looking text stays\nin its reply body.\n\nClose the old control connection, then explicitly call\n`server.open_control(session: ref, reconnect: old_connection)` to reconnect\nwithin the same binding and session. The replacement has a new `generation`\nand retains `previous_generation`. Every new subscription begins with a\n`:reconnect` gap containing both generations and an unknown loss count. Old\nsubscriptions stay closed, and requests are never replayed. Event sequences\ndescribe one connection's observations, not durable pane history.\n\nTyped command coverage includes hierarchy creation/listing,\nrename/split/resize/swap/join/break/respawn/layout operations, link operations,\noptions/hooks/environment, capture/send/paste/pipe/buffers, copy commands,\ndisplay/source-file/wait-for. It does not establish complete flag parity or\nevery compatibility cell; consult the workflow results. RBS validation checks declarations;\ninstalled signature consumers check selected real arguments, blocks and\nreturn values. [Executable recipes](../../docs/recipes.md) run\nagainst installed artifacts; the documentation gate renders YARD and guides\nand checks local destinations and fragments. The [public method inventory](../../docs/reference/api.md)\nlinks exported methods to source and behavioral contracts. These consumer\nchecks do not establish whole-program static typing.\n"
+    },
+    {
+      "path": "gems/libtmux-async/README.md",
+      "content": "# libtmux-async\n\nRun libtmux operations inside an application-owned Async task. This\ngem provides a subprocess facade, ordered mapping, control replies and event\nsubscriptions. Imports start no scheduler, tmux server or background task.\n\nInstall the alpha with `gem install libtmux-async --pre`.\n\nThe [complete program](../../examples/async_cancel.rb) owns an isolated server\nand its cleanup. This excerpt uses that server and creates the Async root:\n\n<!-- example: async_cancel/main -->\n```ruby\nAsync do |parent|\n  LibTmux::Async.open(parent: parent, server: server) do |scope|\n    waiting = parent.async do\n      scope.server.run([\"wait-for\", \"-S\", \"ready\", \";\", \"wait-for\", \"held\"], timeout: 0.5)\n    rescue LibTmux::Cancelled => error\n      error\n    end\n    scope.server.wait_for(\"ready\", timeout: 0.5)\n    Example.check(scope.diagnostics.fetch(:active_process_slots) == 1, \"waiting client lost its slot\")\n    captures = scope.map(scope.server.list_panes.map(&:ref), concurrency: 2) do |ref|\n      scope.server.pane(ref).capture\n    end\n    Example.check(captures.all?(&:success?), \"sibling captures stalled\")\n    waiting.cancel\n    failure = waiting.wait\n    Example.check(failure.is_a?(LibTmux::Cancelled), \"cancellation lost\")\n    Example.check(failure.delivery == :possibly_sent, \"cancelled dispatch claimed no effects\")\n    Example.raises(Errno::ECHILD) { Process.waitpid(failure.pid, Process::WNOHANG) }\n    Example.check(scope.server.diagnostics.fetch(:admitted_requests).zero?, \"cancelled client remains admitted\")\n  end\nend.wait\n```\n<!-- /example -->\n\nOmitting `parent:` uses the existing current Async task. The source server must\noutlive the scope. References keep their source binding identity. Scope exit\nretires its clients and joins its owned tasks; it leaves the borrowed daemon\nalive. A scope rejects use from another thread, process or scheduler. Create a\nseparate scope for each scheduler thread. Interactive terminal attachment stays\non the blocking core facade and raises `UnsupportedFeatureError` on this facade.\n\n`scope.server.run` returns the same binary `CommandResult` as core. Its stdin,\nstdout and stderr are owned by scheduler tasks. A bounded native helper observes\nand reaps each child only after its final signalling handoff. Cancelling the\ncalling task retires its client and raises `Cancelled` with `:not_sent` or\n`:possibly_sent` delivery. An already observed exit completes its bounded drain.\nRepeated cancellation does not restart cleanup deadlines or replace an earlier\noperation failure. Deadlines cannot undo tmux effects.\n\n`scope.map` returns a frozen Array in input order; independent requests may\ncomplete out of order. It caps retained items at 1024 and accounts payload bytes\nin strings, primitive values, `CommandResult`, Arrays and Hashes. Cycles and\nexcessive nesting are refused. Application-defined results require an explicit\n`result_bytes:` callable returning a nonnegative Integer. Keep measured values\nunchanged until the map returns. These payload limits complement item counts;\nthey are not exact Ruby heap measurements.\n\n| Scope limit | Default |\n| --- | --- |\n| Active subprocess clients | 4 |\n| Admitted subprocess requests, including unconsumed results | 32 |\n| Queued request payload | 4 MiB |\n| Retained process and map output payload | 8 MiB |\n| Per-command stdout / stderr | 1 MiB / 256 KiB |\n| Control connections | 4 |\n| Ordinary command deadline | 5 seconds |\n\nControl connections use their own request, reply and subscriber limits. Obtain\none with `scope.server.open_control(session: ref)`. `exchange` returns guarded\n`GuardedReply` blocks with `:boundary_window` attribution. It makes no claim of\nfinal command completion. Outside-block events arrive through `events.next` or\nan explicit `subscribe`; consumer callbacks run outside the parser. Reliable\nsubscriptions raise on overflow. Tail subscriptions report dropped ranges.\nCancelling a dispatched, undrained exchange closes that connection.\n\n`pause_output(pane_id:)` and `resume_output(pane_id:)` retain guarded evidence\nand report possible output loss through gap events. A requested-action gap\ndoes not prove that the action took effect. Close a connection before passing\nit as `reconnect:` to `scope.server.open_control`; the replacement stays owned\nby that scope and reports a new generation plus a gap with unknown loss.\nSubscriptions expose their `generation`; prior subscriptions stay closed.\nReconnect and resume never replay requests or missed output.\n\nThe development bundle pins Async 2.46 and io-event 1.22. The\n[compatibility workflow](https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml)\nexercises the selected Ruby/tmux versions on Linux and macOS and retains\nper-revision results. Package builds and tests do not publish this gem.\n"
+    },
+    {
+      "path": "gems/libtmux-mcp/README.md",
+      "content": "# libtmux-mcp\n\nExpose an existing tmux server over MCP stdio. Read snapshots, capture pane\noutput, wait for events, or explicitly enable creation, input and shell commands.\nThe official MCP SDK handles the protocol; bounded Async tasks handle transport.\n\nInstall the alpha and its `libtmux-mcp` executable:\n\n```console\n$ gem install libtmux-mcp --pre\n```\n\n## Start the server\n\nSet `TMUX_SOCKET` to an existing tmux socket. This command borrows that daemon\nand serves MCP on stdin/stdout:\n\n```console\n$ libtmux-mcp \\\n    --socket \"$TMUX_SOCKET\" \\\n    --endpoint local\n```\n\nUse `--socket-name NAME` instead of `--socket PATH` to select a named socket.\n`--endpoint` sets the public alias used in discovery and resource URIs; it does\nnot select the socket. EOF retires owned clients and preserves the daemon.\n\n| Tools | Default | Purpose |\n| --- | --- | --- |\n| `tmux_capabilities`, `tmux_snapshot` | Enabled | Discover capabilities and query captured metadata |\n| `tmux_capture`, `tmux_wait` | Disabled | Capture a screen or wait for text/process exit |\n| `tmux_create`, `tmux_send`, `tmux_close` | Disabled | Create entities, send text/keys and tear down exact targets |\n| `tmux_run` | Disabled | Run a script in an explicitly enrolled zsh shell |\n\nRepeat `--enable-tool` for each additional tool. For screen capture and waits:\n\n```console\n$ libtmux-mcp \\\n    --socket \"$TMUX_SOCKET\" \\\n    --enable-tool tmux_capture \\\n    --enable-tool tmux_wait\n```\n\nDisabled tools are absent from discovery and denied on direct application calls.\nThe [complete protocol recipe](../../examples/mcp_protocol.rb) exercises\ndiscovery, snapshots, default denial, enabled mutations, cancellation and EOF\ncleanup through actual pipes, including the installed executable.\n\n## Snapshots, capture and waits\n\nSnapshot pages retain one immutable capture and query. Cursor expiry or eviction\nreturns an error; it never substitutes a new live listing. Defaults retain up to\n16 captures and 8 MiB for 30 seconds, with a five-second acquisition deadline and\none-MiB structured response limit. A cursor pages captured metadata; it does not\nclaim that an old pane process still exists. Schema validation supplements the\ncore decoder's stricter byte, depth, node and duplicate-key rules.\n\nOpt into `tmux_capture` for a bounded screen snapshot. Results retain line\nendings, encode invalid UTF-8 as base64, and distinguish truncated screen\ncontent from unknown history continuity. Tracking produces a retained cursor;\nsubsequent calls return a splice against that exact captured state. A screen\ndelta does not establish that every intervening output byte was observed.\n\nCapture refuses nonempty effective `after-capture-pane` hooks, including\ninherited sparse entries. On tmux 3.2a–3.4, callers must keep capture-hook\nconfiguration stable throughout observation: those versions require a separate\nhook preflight. tmux 3.5+ checks the hook in the capture command queue. Both paths\nretain an explicit session/pane context and refuse its removal instead of\nswitching to another session's hooks. Process tracking retains its native\nidentity checks on every version that supports it.\n\n`tmux_wait` observes screen text or process exit through events. Canceling it\nretires its observation resources without signaling the pane program. Strong\nprocess tracking requires tmux 3.3 or later and a native identity backend:\nLinux peer pidfds with matching process namespaces, or Darwin kqueue process\nobservation. Acquisition verifies the live daemon and pane before retaining\na cursor; unavailable evidence produces an explicit refusal. The\n[compatibility workflow](https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml)\nrecords each exact platform/version result, including the required tmux 3.2a\nrefusal and positive identity cases on later versions.\n\nResource templates expose metadata pages and pane screens under encoded\nendpoint/generation URIs. They enforce the same policy and response limits as\ntheir tools. Metadata pages preserve capture identity; screen resources\ninclude interval, truncation and history-continuity metadata. Resource\nsubscriptions are not advertised.\n\n## Create, send and close\n\nAdd `--enable-tool tmux_create`, `--enable-tool tmux_send` or\n`--enable-tool tmux_close` to authorize those tools. Creation accepts argument\narrays; sending text and sending named keys are separate variants. Mutation\nresults contain delivery evidence and positively returned references.\n`dispatch_only` input results do not claim program completion, and unknown\neffects remain unknown after cancellation.\n\n## Run authored commands\n\n`tmux_run` requires separate policy and shell enrollment. Add\n`--enable-tool tmux_run --enroll-pane %ID=FILE` for each exact pane, then\nexplicitly source the generated file in that pane's interactive zsh 5.9.\nThe CLI creates a private setup file and never types into the terminal.\nIt refuses existing files and symlinks. Invitations expire after 60 seconds;\n`--enrollment-timeout` accepts at most 300 seconds. At most eight panes may be\nenrolled. EOF retires pending enrollment and removes only files the CLI owns.\n\nThe tool accepts an exact pane target, a POSIX `script`, and separate\n`stdout_limit`/`stderr_limit` byte counts. Scripts may contain at most 65,536\nbytes. Each output defaults to 65,536 bytes and is capped at 262,144; the\napplication reserves its worst-case serialized response before authorization.\nThe helper inherits the enrolled shell's cwd and exported environment, uses\nclosed stdin, and reports separate UTF-8 or base64 outputs. Nonzero exit and\nsignal termination are completion results. Output overflow is an error with\ncompletion unobserved, not silently truncated success. Shell variables,\nfunctions, options and cwd changes do not persist in the interactive parent.\n\nAn idle, empty primary ZLE editor receives the request through a private socket.\nA guarded tmux queue operation authorizes one script digest for one retained\nserver, pane process and enrollment generation. Execution may follow that\nauthorization; a later respawn does not redirect the prepared helper to its\nreplacement. Error responses retain known authorization and native completion\nreceipts. Cancellation does not prove that arbitrary descendants stopped.\nThe Linux and macOS compatibility jobs exercise enrollment and the installed\nhelper dependency closure; consult their results for the revision being used.\n\n## Embed in Ruby\n\nRequire `libtmux/mcp`; imports start no tmux process, scheduler or MCP server.\n`Application` borrows an application-owned `LibTmux::Async::Server`. Its\n`sdk_server` supplies the SDK server consumed by `StdioTransport`. Both objects\nstay on that application's reactor thread. See the\n[execution guide](../../docs/modes.md) for result and ownership boundaries.\n\nFor shell enrollment, call `Application#invite_shell(reference, timeout:,\nexpires_in:)` and pass the returned invitation to `accept_shell`. The invitation\nexposes an immutable `shell_arguments` array for an explicitly sourced setup\ncommand and a monotonic `expires_at`. Its acquisition deadline is separate from\nits enrollment lifetime. The application owns invitations and accepted\nconnections until `close`; direct enrollment calls enforce tool policy.\n"
+    },
+    {
+      "path": "gems/libtmux-workspace/README.md",
+      "content": "# libtmux-workspace\n\nLoad bounded YAML or JSON, inspect an immutable creation plan, then explicitly\napply it to an open libtmux server. The library\nand installed command-line executable share the core\n[compatibility matrix](https://github.com/libtmux/libtmux-ruby/actions/workflows/compatibility.yml);\nconsult its exact per-revision results.\n\nThe gem declares Ruby 3.3 or newer and depends on the same-version `libtmux`\ngem, JSON 3.0 and Psych 5.5. See the repository's\n[contribution guide](../../.github/CONTRIBUTING.md) for local builds and checks.\nImports and planning do not start tmux or run commands.\n\nInstall the alpha and its `libtmux-workspace` executable:\n\n```console\n$ gem install libtmux-workspace --pre\n```\n\n## Example\n\nSave this declared subset of tmuxp-style data as `workspace.yaml`. Relative\ndirectories resolve against the configuration file's directory.\n\n<!-- example: workspace/config -->\n```yaml\nsession_name: work\nenvironment:\n  PROJECT_MODE: development\nwindows:\n  - window_name: editor\n    window_index: 1\n    layout: tiled\n    panes:\n      - shell_command: printf 'editor ready\\n'\n      - {}\n```\n<!-- /example -->\n\nThe [complete workspace program](../../examples/workspace_apply.rb) creates an\nisolated server, applies this document and checks compensation after a later\nfailure. Calling `apply` authorizes the configuration's shell commands. This\nexcerpt runs inside that program's cleanup wrapper:\n\n<!-- example: workspace_apply/main -->\n```ruby\nworkspace = LibTmux::Workspace.load(File.join(__dir__, \"workspace.yaml\"))\nplan = workspace.plan(snapshot: server.snapshot)\nExample.check(server.list_sessions.size == 1, \"planning changed tmux\")\nresult = plan.apply(server: server)\nExample.check(result.success?, \"workspace apply failed\")\nExample.check(result.effects.any? { |effect| effect.outcome == :dispatch_only }, \"shell dispatch overclaims completion\")\ncrowded = LibTmux::Workspace.parse(JSON.generate({\n  session_name: \"crowded\", windows: [{window_name: \"small\", panes: Array.new(40) { {} }}]\n}), format: :json, base_directory: __dir__)\nerror = Example.raises(LibTmux::Workspace::ApplyError) do\n  crowded.plan.apply(server: server, compensate: true)\nend\nExample.check(!error.result.created_refs.empty?, \"failure lost partial creation ledger\")\nExample.check(error.result.compensation == :completed, \"owned compensation failed\")\nExample.check(server.list_sessions.map(&:ref).include?(borrowed.ref), \"borrowed session was removed\")\n```\n<!-- /example -->\n\n## Configuration\n\nThe plain declared subset has effective version 1. Optional `profile` and\n`version` must appear together as `libtmux-ruby.workspace` and `1`.\n`workspace.to_h` exports an immutable, normalized, reloadable configuration.\nIt contains expanded values and absolute directories; callers control its\nstorage and disclosure.\n\n- Root: `session_name`, nonempty `windows`, `options`, `window_options`.\n- Window: `window_name`, nonempty `panes`, `window_index`, `focus`, `layout`,\n  `options`. Indexes are unique nonnegative integers; unspecified indexes use\n  the lowest available value starting at the declared `base-index` or zero.\n- Pane: a command string or a mapping with `focus`, `split`, `size`. Split is\n  `horizontal` or `vertical`. Size is positive cells or `1%` through `99%`;\n  neither applies to the initial pane. Explicit sizes cannot accompany a\n  final named layout.\n- Root, windows and pane mappings accept `start_directory`, `environment`,\n  `shell_command` and `shell_command_before`. Environment maps merge from\n  parent to child. Commands inherit unless overridden; before-commands append\n  in parent-to-child order. Command values accept a string or string array.\n\nAt most one window and one pane per window can declare focus; each defaults\nto the first. Layouts are `even-horizontal`, `even-vertical`, `main-horizontal`,\n`main-vertical` and `tiled`. Unknown fields and unsupported features fail with\na `ConfigError` identifying their configuration position.\n\nSession options accept boolean `status`, `mouse`, `renumber-windows`;\nnonnegative `base-index`, `history-limit`, `status-interval`; and enumerated\n`status-position` and `status-justify`. Window options accept boolean\n`automatic-rename`, `allow-rename`, `remain-on-exit`, `synchronize-panes`,\n`aggressive-resize`; nonnegative `pane-base-index`, `main-pane-width`,\n`main-pane-height`; text `window-status-format`, `window-status-current-format`;\nand enumerated `pane-border-status`. Option text remains tmux option text,\nincluding any formats that tmux evaluates.\n`pane-base-index` cannot exceed 65535; the other numeric options accept\nintegers through 2147483647.\n\nYAML tags, anchors, aliases, duplicate keys, multiple documents and complex\nmapping keys are rejected. JSON duplicate keys are rejected too. No Ruby,\nERB, plugins or callbacks are evaluated. Defaults bound source and canonical\nbytes to 1 MiB, strings to 64 KiB, nesting to 32, nodes to 10,000, windows to\n128 and panes to 1,024. The corresponding `max_*` parse/load keywords can\nadjust these positive limits. Configuration files must be regular files.\n\n`${NAME}` substitution is opt-in for directories and environment values:\npass `expand_environment: true, environment: {\"NAME\" => \"value\"}` to load or\nparse. Only the supplied bounded mapping is consulted. Shell text and option\nvalues are unchanged; `~` has no special path meaning. Missing variables fail\nvalidation. Parsing checks path syntax; apply checks current accessibility.\nConcurrent filesystem changes can still trigger tmux's cwd fallback.\n\n## Apply and failure results\n\n`workspace.plan(snapshot: snapshot)` retains that capture's binding identity\nand rejects a captured name conflict. Every apply takes a fresh snapshot and\nrechecks identity and name absence. The plan creates a new session; it does\nnot reconcile, replace or remove a preexisting workspace. The first window\nand pane from each creation command are reused.\n\nApply is synchronous, uses one monotonic timeout across its core operations,\nand accepts a cancellation token. Panes run `/bin/sh`; explicit initial pane\nenvironment overrides do not modify the session environment. Window indexes,\nsplits, options, layout and focus follow the plan's order. Temporary local\noption overrides disable renumbering and pane synchronization during setup;\nthe plan then restores declared values or inheritance.\n\nSession options apply before subsequent windows and split panes are created.\nOn tmux 3.2a–3.6, the reused initial pane retains the global `history-limit`\ninherited at session creation. Later panes use the configured session value.\nFor uniform history on these versions, configure the server's global value\nbefore applying the workspace. Apply does not change global options or replace\nthe initial pane. On tmux 3.7+, setting the option also updates existing grids.\n\nShell commands are sent as literal text followed by Enter. Both insertion\nand Enter are dispatch effects: embedded newlines can execute during text\ninsertion. Success proves tmux accepted the dispatch, not that a shell\ncommand finished or succeeded. Shell commands can leave effects beyond tmux.\n\nAn `ApplyError` exposes an immutable `result`: completed step IDs, positively\nidentified `created_refs`, observed or dispatch-only effects, failed action,\nuncertainty and cleanup diagnostics. Diagnostics omit command payloads and\npaths. Lost creation replies stay uncertain; names are never used to guess\nownership. A caller may pass `compensate: true` to kill only the positively\nreturned new session on failure, after an atomic tmux guard proves that every\ncurrent window and pane has a positively identified created reference. Unknown\ninitial entities or borrowed entities moved into that session cause refusal.\nCleanup uses a separate 0.5-second budget. Compensation status is explicit and\ncannot undo shell effects. The default\npreserves partial state for inspection. Applying or compensating does not\nclose the supplied server binding.\n\n## Command-line interface\n\nThe gem installs `libtmux-workspace`. `validate` and offline\n`plan` do not contact tmux. Without a filename, discovery requires exactly one\n`.tmuxp.yaml`, `.tmuxp.yml` or `.tmuxp.json` in the current directory.\n\nCheck the installed gem version without reading a configuration or contacting\ntmux:\n\n```console\n$ libtmux-workspace --version\n```\n\n```console\n$ libtmux-workspace validate workspace.yaml\n```\n\nHuman plans list ordered operations and their effects. `--json` prints the\nsame plan data as `Plan#to_h`, including configured command text and paths.\n\n```console\n$ libtmux-workspace plan \\\n    --json \\\n    workspace.yaml\n```\n\n`load` and `plan --live` require `--socket` for an existing server. This\ndetached creation example uses an explicitly supplied `TMUX_SOCKET` value:\n\n```console\n$ libtmux-workspace load \\\n    --socket \"$TMUX_SOCKET\" \\\n    --json \\\n    workspace.yaml\n```\n\n`--timeout` bounds each apply, live capture or subsequent switch operation\nand defaults to 5 seconds.\n`--compensate` enables guarded cleanup after apply failure. Environment\nexpansion requires both `--expand-environment` and explicit `--env NAME=VALUE`\narguments; ambient environment variables are not copied into that mapping.\n\n`load --attach` opens the CLI's `/dev/tty` after creation and runs an owned\nterminal client until the user detaches. It requires a valid `TERM`. Failure\nto open or attach the terminal retains the successful apply ledger and\nreturns status 3. `load --switch CLIENT` switches the explicit current tmux\nclient selector to the created session after apply, preserving the session's\nenvironment. It accepts a current client name, full TTY path or TTY path\nwithout `/dev/`; native first-match behavior applies. A missing client fails\nwithout fallback and retains the created session and ledger with status 3.\nMissing or invalid selector arguments fail before creation. Use\n`--switch=VALUE` for a selector beginning with `-`.\n\nThe selector is resolved at dispatch; a reconnect matching it is eligible.\nIt is not a captured client reference or proof of terminal ownership. Attach\nand switch are mutually exclusive. Neither operation infers a latest client,\nand library `Plan#apply` performs neither operation.\n\n| Exit status | Meaning |\n| --- | --- |\n| 0 | Validation, planning or apply succeeded; requested attach/switch succeeded |\n| 1 | Execution failed before known application effects |\n| 2 | Configuration or arguments are invalid |\n| 3 | Application was partial or uncertain, or a later attach/switch/cleanup failed |\n| 130 | Interrupted; available effect ledger is retained |\n\nJSON mode writes one result or error object to stdout. Apply errors include\n`ApplyResult#to_h`; human errors write the diagnostic and any ledger to stderr.\nDiagnostics omit configuration payloads. Explicit plan rendering and canonical\nconfiguration export contain those values by design.\n"
+    }
+  ]
+}
diff --git a/site/src/data/port-guides/scala.json b/site/src/data/port-guides/scala.json
index b07dd66c..3dc33443 100644
--- a/site/src/data/port-guides/scala.json
+++ b/site/src/data/port-guides/scala.json
@@ -1,16 +1,16 @@
 {
   "source": {
     "repository": "libtmux/libtmux-java",
-    "revision": "49c83f633c6d6425ba93c0c30af0bd91a3910364"
+    "revision": "3c9ad0ee5698554b9311b3fbc63d3e33873830c6"
   },
   "guides": [
     {
       "path": "libtmux-scala/README.md",
-      "content": "# libtmux-scala\n\n**Scala 3 collections and opaque handles over libtmux for Java.**\n\nUse Scala collections and explicit effects to inspect and operate tmux through\nlibtmux for Java. The direct-style facade's handles are opaque aliases of the\nJava ones — lossless by construction, never a hand-copied parallel type — and\nreturn immutable `Vector` and `Option` values. The\n[separate Cats module](../libtmux-scala-cats/README.md) supplies scoped\neffects and FS2 observations. Both retain the original Java handles, targeting\nrules and command engine.\n\n**This project is alpha.** Releases carry an `-alpha` prerelease tag. The API is\nnot settled, and any release may change or remove exported identifiers without a\ndeprecation period. Pin an exact version rather than a range. Not recommended\nfor production.\n\n## Requirements\n\nScala 3.9 and JDK 25 or newer; there is no Scala 2.13 build. tmux 3.2a through\n3.7c, which the Java library supports and every tmux lane in CI runs these\nsuites against. See [Compatibility](../docs/guide/scala/compatibility.md).\n\n## Installation\n\n<!-- snippet: scala-build: readme-install -->\n```sbt\nlibraryDependencies += \"io.github.libtmux\" %% \"libtmux-scala\" % \"<version>\"\n```\n\nFrom Gradle or Maven the coordinate is `io.github.libtmux:libtmux-scala_3`.\nThe version is always `libtmux`'s own: the Scala artifacts are on Maven Central\nand release with the Java ones. Core depends on `libtmux` and the Scala 3 library only; Cats, FS2\nand Ox arrive through [`libtmux-scala-cats`](../libtmux-scala-cats/) and\n[`libtmux-scala-ox`](../libtmux-scala-ox/).\n\n## Inspect captured panes\n\nStart with [a first client](../docs/guide/scala/getting-started.md#a-first-client) to construct\n`ServerConfig` from your tmux executable, owned socket and configuration file.\nHere `config` selects an existing server. Opening the client does not create a\nsession. This operation closes its owned client while leaving the daemon\nrunning.\n\n<!-- snippet: scala-sync: readme-inspect-panes -->\n```scala\nimport io.github.libtmux.scaladsl.{config => _, *}\nimport scala.util.Using\n\nUsing.resource(Server.open(config)) { server =>\n  val panes = server.panes()\n  val named = panes.filter(_.info.title().nonEmpty)\n  val commands = named.map(_.info.currentCommand())\n  assert(commands.size <= panes.size)\n  assert(panes.forall(p => p.window.info.context().equals(p.info.context())))\n}\n```\n\n`server.panes()` acquires state. Reading `info`, traversing `window`, or\nfiltering the captured vector performs no further tmux commands. `refresh()`\nreturns a new capture. A failed acquisition raises the original Java error;\nit does not become an empty vector.\n\n## Documentation\n\n- [Getting started](../docs/guide/scala/getting-started.md): installation, a\n  first owned client, and building from source.\n- [Queries](../docs/guide/scala/query.md): native collections, the typed field\n  DSL and strict cardinality.\n- [Ownership](../docs/guide/scala/ownership.md): captured handles, borrowing and\n  cleanup.\n- [Execution](../docs/guide/scala/execution.md): direct-style calls, bounded\n  effects and command outcomes.\n- [Streaming](../docs/guide/scala/streaming.md): subscriptions, cancellation and\n  visible loss.\n- [Compatibility](../docs/guide/scala/compatibility.md): compilers, runtimes and\n  what CI runs.\n- [Examples](../examples/): runnable programs, each executed against a real tmux.\n\nThe [Java guide](../docs/guide/scala.md) shows direct Java use without the\nfacade. Source contracts live beside [direct-style operations][server]\nand [Cats resources][cats-server]. For changes to existing APIs, see the\nrepository's [migration notes](../MIGRATION.md).\n\n[server]:\n  src/main/scala/io/github/libtmux/scaladsl/Server.scala\n[cats-server]:\n  ../libtmux-scala-cats/src/main/scala/io/github/libtmux/scaladsl/cats/Server.scala\n"
+      "content": "<!-- libtmux-logo -->\n<p align=\"center\">\n  <picture>\n    <source srcset=\"assets/logo.svg\" type=\"image/svg+xml\">\n    <img src=\"assets/logo.png\" width=\"128\" height=\"128\" alt=\"libtmux for Scala\">\n  </picture>\n</p>\n<!-- /libtmux-logo -->\n\n<div align=\"center\">\n\n# libtmux-scala\n\n**Scala 3 collections and opaque handles over libtmux for Java.**\n\n</div>\n\nUse Scala collections and explicit effects to inspect and operate tmux through\nlibtmux for Java. The direct-style facade's handles are opaque aliases of the\nJava ones — lossless by construction, never a hand-copied parallel type — and\nreturn immutable `Vector` and `Option` values. The\n[separate Cats module](../libtmux-scala-cats/README.md) supplies scoped\neffects and FS2 observations. Both retain the original Java handles, targeting\nrules and command engine.\n\n**This project is alpha.** Releases carry an `-alpha` prerelease tag. The API is\nnot settled, and any release may change or remove exported identifiers without a\ndeprecation period. Pin an exact version rather than a range. Not recommended\nfor production.\n\n## Requirements\n\nScala 3.9 and JDK 25 or newer; there is no Scala 2.13 build. tmux 3.2a through\n3.7c, which the Java library supports and every tmux lane in CI runs these\nsuites against. See [Compatibility](../docs/guide/scala/compatibility.md).\n\n## Installation\n\n<!-- snippet: scala-build: readme-install -->\n```sbt\nlibraryDependencies += \"io.github.libtmux\" %% \"libtmux-scala\" % \"0.0.1-alpha.17\"\n```\n\nFrom Gradle or Maven the coordinate is `io.github.libtmux:libtmux-scala_3`.\nThe version is always `libtmux`'s own: the Scala artifacts are on Maven Central\nand release with the Java ones. Core depends on `libtmux` and the Scala 3 library only; Cats, FS2\nand Ox arrive through [`libtmux-scala-cats`](../libtmux-scala-cats/) and\n[`libtmux-scala-ox`](../libtmux-scala-ox/).\n\n## Inspect captured panes\n\nStart with [a first client](../docs/guide/scala/getting-started.md#a-first-client) to construct\n`ServerConfig` from your tmux executable, owned socket and configuration file.\nHere `config` selects an existing server. Opening the client does not create a\nsession. This operation closes its owned client while leaving the daemon\nrunning.\n\n<!-- snippet: scala-sync: readme-inspect-panes -->\n```scala\nimport io.github.libtmux.scaladsl.{config => _, *}\nimport scala.util.Using\n\nUsing.resource(Server.open(config)) { server =>\n  val panes = server.panes()\n  val named = panes.filter(_.info.title().nonEmpty)\n  val commands = named.map(_.info.currentCommand())\n  assert(commands.size <= panes.size)\n  assert(panes.forall(p => p.window.info.context().equals(p.info.context())))\n}\n```\n\n`server.panes()` acquires state. Reading `info`, traversing `window`, or\nfiltering the captured vector performs no further tmux commands. `refresh()`\nreturns a new capture. A failed acquisition raises the original Java error;\nit does not become an empty vector.\n\n## Documentation\n\n- [Getting started](../docs/guide/scala/getting-started.md): installation, a\n  first owned client, and building from source.\n- [Queries](../docs/guide/scala/query.md): native collections, the typed field\n  DSL and strict cardinality.\n- [Ownership](../docs/guide/scala/ownership.md): captured handles, borrowing and\n  cleanup.\n- [Execution](../docs/guide/scala/execution.md): direct-style calls, bounded\n  effects and command outcomes.\n- [Streaming](../docs/guide/scala/streaming.md): subscriptions, cancellation and\n  visible loss.\n- [Compatibility](../docs/guide/scala/compatibility.md): compilers, runtimes and\n  what CI runs.\n- [Examples](../examples/): runnable programs, each executed against a real tmux.\n\nThe [Java guide](../docs/guide/scala.md) shows direct Java use without the\nfacade. Source contracts live beside [direct-style operations][server]\nand [Cats resources][cats-server]. For changes to existing APIs, see the\nrepository's [migration notes](../MIGRATION.md).\n\n[server]:\n  src/main/scala/io/github/libtmux/scaladsl/Server.scala\n[cats-server]:\n  ../libtmux-scala-cats/src/main/scala/io/github/libtmux/scaladsl/cats/Server.scala\n"
     },
     {
       "path": "docs/guide/scala/getting-started.md",
-      "content": "# Getting started\n\nThe Scala facades need Scala 3.9 and JDK 25 or newer, and tmux 3.2a through\n3.7c on the machine they drive.\n\n## Install\n\nThree artifacts, all in group `io.github.libtmux` and all at the same version\nas `libtmux` itself. `%%` adds the `_3` suffix that marks a Scala 3 artifact.\nThey are on Maven Central and release with the Java artifacts.\n\n- **`libtmux-scala_3`** — direct-style handles, collections and the typed query\n  DSL.\n- **`libtmux-scala-cats_3`** — Cats Effect resources and FS2 observations.\n- **`libtmux-scala-ox_3`** — an Ox `Flow` over subscriptions and live views.\n\n<!-- snippet: scala-build: install-core -->\n```sbt\nlibraryDependencies += \"io.github.libtmux\" %% \"libtmux-scala\" % \"<version>\"\n```\n\nFor Cats Effect and FS2, or for Ox, add the matching module:\n\n<!-- snippet: scala-build: install-cats -->\n```sbt\nlibraryDependencies += \"io.github.libtmux\" %% \"libtmux-scala-cats\" % \"<version>\"\n```\n\n<!-- snippet: scala-build: install-ox -->\n```sbt\nlibraryDependencies += \"io.github.libtmux\" %% \"libtmux-scala-ox\" % \"<version>\"\n```\n\nFrom Gradle or Maven, name the suffixed artifact directly:\n`io.github.libtmux:libtmux-scala_3:<version>`. The core facade depends on\n`libtmux` and the Scala 3 library, and on nothing else.\n\n## A first client\n\nThe function below takes three caller-supplied values and constructs a Java\n`ServerConfig` before opening the Scala client:\n\n| Parameter | Value to supply |\n| --- | --- |\n| `binary` | Absolute path to your tmux executable |\n| `socket` | An isolated socket you own under `/tmp/libtmux-java-dev/` |\n| `configFile` | Your tmux configuration file, or `/dev/null` for none |\n\nFor example, choose `/tmp/libtmux-java-dev/scala-start/socket`; the function\ncreates its parent directory. Opening the client does not create tmux;\n`newSession` does. The operation creates a session, splits its window, verifies\nthe resulting panes and kills that session. Closing the client is separate\nfrom session cleanup. An existing server's other sessions remain running;\ntmux normally exits when its final session closes.\n\nCall `firstClient` with your three values from your application.\nThe final call in this tested snippet takes those inputs from the owned test\nfixture's `config`; the function builds and uses its own configuration.\n\n<!-- snippet: scala-sync: getting-started-session -->\n```scala\nimport io.github.libtmux.{\n  Layout, ServerConfig, ServerEndpoint, SessionSpec, SplitSpec\n}\nimport io.github.libtmux.scaladsl.{config => _, *}\nimport java.nio.file.{Files, Path}\nimport java.time.Duration\nimport scala.util.Using\n\ndef firstClient(binary: String, socket: Path, configFile: Path): Unit = {\n  require(Path.of(binary).isAbsolute, \"supply an absolute tmux executable\")\n  val ownedSocket = socket.toAbsolutePath.normalize()\n  require(\n    ownedSocket.startsWith(Path.of(\"/tmp/libtmux-java-dev\")) ||\n      ownedSocket.startsWith(Path.of(\"/tmp/libtmux-java-test\")),\n    \"choose a socket under an owned libtmux Java directory\"\n  )\n  Files.createDirectories(ownedSocket.getParent)\n  val selected = ServerConfig.builder()\n    .binary(binary)\n    .endpoint(ServerEndpoint.socketPath(ownedSocket))\n    .configFile(configFile)\n    .defaultTimeout(Duration.ofMillis(800))\n    .build()\n\n  Using.resource(Server.open(selected)) { server =>\n    val session = server.newSession(\n      SessionSpec.builder().named(\"scala-start\").running(\"cat\", \"-\").build()\n    )\n    try {\n      val window = session.windows.head\n      val second = window.split(\n        SplitSpec.builder().running(\"cat\", \"-\").build()\n      )\n      window.selectLayout(Layout.EVEN_HORIZONTAL)\n      second.select()\n      // window.panes is CAPTURED: it answers from window's own frozen capture, taken before the\n      // split, so this refreshes first rather than reading stale data.\n      val panes = window.refresh().panes\n      assert(panes.size == 2)\n      assert(panes.exists(_.info.id().value() == second.info.id().value()))\n    } finally session.kill()\n  }\n}\n\nconfig.endpoint() match {\n  case endpoint: ServerEndpoint.SocketPath =>\n    firstClient(\n      config.binaryPath(),\n      endpoint.path(),\n      config.configFile().orElse(Path.of(\"/dev/null\"))\n    )\n  case _ => throw new IllegalArgumentException(\"an explicit socket is required\")\n}\n```\n\nTimeouts are `scala.concurrent.duration.FiniteDuration` at every public entry\npoint, converted once at the boundary: `pane.awaitText(\"$\", 5.seconds)`\nnever surfaces `java.time.Duration` to the caller.\n\nFollow with [queries](query.md), [ownership](ownership.md), then\n[execution](execution.md). For immediate access without the facade, use the\n[direct Java guide](../scala.md).\n\n## Build from source\n\nThe facades build with the rest of the repository, from its root:\n\n```console\n$ ./gradlew :libtmux-scala:check :libtmux-scala-cats:check :libtmux-scala-ox:check\n```\n\nThe real-tmux suites run with the Java ones in `integration-tests`:\n\n```console\n$ ./gradlew :integration-tests:test --tests 'io.github.libtmux.scaladsl.*'\n```\n\nFormat Scala sources before committing:\n\n```console\n$ ./gradlew spotlessApply\n```\n\nThe API documentation, with a browser for every source it documents, generated\noperations included, starts at `libtmux-scala/build/docs/scaladoc/index.html`:\n\n```console\n$ ./gradlew :libtmux-scala:scaladocSite\n```\n\nBegin with [direct-style `Server`][server] or [Cats `Server`][cats-server].\n\n[server]:\n  ../../../libtmux-scala/src/main/scala/io/github/libtmux/scaladsl/Server.scala\n[cats-server]:\n  ../../../libtmux-scala-cats/src/main/scala/io/github/libtmux/scaladsl/cats/Server.scala\n"
+      "content": "# Getting started\n\nThe Scala facades need Scala 3.9 and JDK 25 or newer, and tmux 3.2a through\n3.7c on the machine they drive.\n\n## Install\n\nThree artifacts, all in group `io.github.libtmux` and all at the same version\nas `libtmux` itself. `%%` adds the `_3` suffix that marks a Scala 3 artifact.\nThey are on Maven Central and release with the Java artifacts.\n\n- **`libtmux-scala_3`** — direct-style handles, collections and the typed query\n  DSL.\n- **`libtmux-scala-cats_3`** — Cats Effect resources and FS2 observations.\n- **`libtmux-scala-ox_3`** — an Ox `Flow` over subscriptions and live views.\n\nFor a new sbt project, save this as `build.sbt`:\n\n<!-- snippet: scala-build: install-core -->\n```sbt\nscalaVersion := \"3.9.0\"\nscalacOptions += \"-release:25\"\nlibraryDependencies += \"io.github.libtmux\" %% \"libtmux-scala\" % \"0.0.1-alpha.17\"\n```\n\nFor Cats Effect and FS2, or for Ox, add the matching module:\n\n<!-- snippet: scala-build: install-cats -->\n```sbt\nlibraryDependencies += \"io.github.libtmux\" %% \"libtmux-scala-cats\" % \"0.0.1-alpha.17\"\n```\n\n<!-- snippet: scala-build: install-ox -->\n```sbt\nlibraryDependencies += \"io.github.libtmux\" %% \"libtmux-scala-ox\" % \"0.0.1-alpha.17\"\n```\n\nFrom Gradle or Maven, name the suffixed artifact directly:\n`io.github.libtmux:libtmux-scala_3:0.0.1-alpha.17`. The core facade depends on\n`libtmux` and the Scala 3 library, and on nothing else.\n\n## A first client\n\nSave this complete program as `src/main/scala/Main.scala`. It selects a fresh\nsocket under `/tmp/libtmux-java-dev/`, creates a session with two panes, checks\nthe captured layout, and stops its private daemon before closing the client.\nIt reads tmux from `PATH`; set `LIBTMUX_TMUX` to select another binary.\n\n<!-- snippet: scala-main: getting-started-session -->\n```scala\nimport io.github.libtmux.{\n  Layout, ServerConfig, ServerEndpoint, SessionSpec, SplitSpec\n}\nimport io.github.libtmux.scaladsl.*\nimport java.nio.file.{Files, Path}\nimport scala.util.Using\n\nobject Main {\n  def main(args: Array[String]): Unit = {\n    val root = Files.createDirectories(Path.of(\"/tmp/libtmux-java-dev\"))\n    val directory = Files.createTempDirectory(root, \"scala-start-\")\n    val socket = directory.resolve(\"s\")\n    val config = ServerConfig.builder()\n      .binary(sys.env.getOrElse(\"LIBTMUX_TMUX\", \"tmux\"))\n      .endpoint(ServerEndpoint.socketPath(socket))\n      .configFile(Path.of(\"/dev/null\"))\n      .build()\n    try {\n      Using.resource(Server.open(config)) { server =>\n        try {\n          val session = server.newSession(\n            SessionSpec.builder().named(\"scala-start\").running(\"cat\", \"-\").build()\n          )\n          val window = session.windows.head\n          val second = window.split(\n            SplitSpec.builder().running(\"cat\", \"-\").build()\n          )\n          window.selectLayout(Layout.EVEN_HORIZONTAL)\n          second.select()\n          val panes = window.refresh().panes\n          assert(panes.size == 2)\n          assert(panes.exists(_.info.id().value() == second.info.id().value()))\n          println(s\"created ${panes.size} panes\")\n        } finally server.killServer()\n      }\n    } finally {\n      Files.deleteIfExists(socket)\n      Files.deleteIfExists(directory)\n    }\n  }\n}\n```\n\nRun it with sbt:\n\n```console\n$ sbt run\n```\n\nThe output includes `created 2 panes`. `window.refresh()` captures the pane\nlist after the split; the original window's captured list still has one pane.\n`Using.resource` closes the library client. The separate `killServer` call\nstops the daemon because this program created and owns it. When connecting to\nan existing daemon, leave its lifetime with its owner and remove only sessions\nyour application created.\n\nTimeouts are `scala.concurrent.duration.FiniteDuration` at every public entry\npoint, converted once at the boundary: `pane.awaitText(\"$\", 5.seconds)`\nnever surfaces `java.time.Duration` to the caller.\n\nFollow with [queries](query.md), [ownership](ownership.md), then\n[execution](execution.md). The [API reference][server] documents the direct-style server.\n\n## Build from source\n\nThe facades build with the rest of the repository, from its root:\n\n```console\n$ ./gradlew :libtmux-scala:check :libtmux-scala-cats:check :libtmux-scala-ox:check\n```\n\nThe real-tmux suites run with the Java ones in `integration-tests`:\n\n```console\n$ ./gradlew :integration-tests:test --tests 'io.github.libtmux.scaladsl.*'\n```\n\nFormat Scala sources before committing:\n\n```console\n$ ./gradlew spotlessApply\n```\n\nThe API documentation, with a browser for every source it documents, generated\noperations included, starts at `libtmux-scala/build/docs/scaladoc/index.html`:\n\n```console\n$ ./gradlew :libtmux-scala:scaladocSite\n```\n\nBegin with [direct-style `Server`][server] or [Cats `Server`][cats-server].\n\n[server]:\n  ../../../libtmux-scala/src/main/scala/io/github/libtmux/scaladsl/Server.scala\n[cats-server]:\n  ../../../libtmux-scala-cats/src/main/scala/io/github/libtmux/scaladsl/cats/Server.scala\n"
     },
     {
       "path": "docs/guide/scala/query.md",
@@ -30,7 +30,7 @@
     },
     {
       "path": "docs/guide/scala/compatibility.md",
-      "content": "# Compatibility\n\nThe Scala facades build, test and publish with the rest of the repository, so\nthey meet the same gates the Java library does.\n\n## Compilers and runtimes\n\nScala 3.9 only — there is no 2.13 build — compiled to JDK 25 bytecode. CI runs\nthe facades' unit suites, their real-tmux suites, the documented Scala examples\nand the runnable programs on JDK 25 and 27 on Linux, and on macOS.\n\nEvery lane of the [tmux matrix][tmux-matrix] runs the real-tmux suites against\nits own tmux: `3.2a`, `3.3`, `3.3a`, `3.4`, `3.5`, `3.6`, `3.7`, `3.7a`, `3.7b`\nand `3.7c`. The Scala fixture takes the lane's tmux the same way the Java one\ndoes.\n\n## Artifacts\n\n- **`libtmux-scala_3`** — direct-style operations and the typed query DSL.\n- **`libtmux-scala-cats_3`** — Cats Effect resources and FS2 observations.\n- **`libtmux-scala-ox_3`** — an Ox `Flow` over subscriptions and live views.\n\nCore's runtime dependencies are the Scala 3 library and `libtmux`. Cats Effect\nand FS2 belong to `libtmux-scala-cats`, Ox to `libtmux-scala-ox`. None depends\non Jackson, JUnit, Kotlin, MCP or the workspace packages.\n\nThe Scala artifacts release with the Java ones, at the same version, in the\nsame Central deployment, signed and attested alike. `libtmux-bom` manages them\ntoo, so one BOM version selects a matching Java and Scala set.\n\n## The generated and handwritten surface\n\nEvery direct-style extension method and Cats per-operation forward that reaches\ntmux is generated from the operation catalog `libtmux` ships, by\n[`ScalaOperationGenerator`][generator] — never hand-copied per method, so it\ncannot drift from what Java exposes. `WAIT`, `STREAM` and `LIFECYCLE`\noperations are written by hand, for their cancellation or resource scoping:\n`Server.open`/`fromJava`/`within`/`control`, `Pane.awaitText`/`run`/`await`,\n`LiveView`, `LiveServer`, and both modules' `Observation`.\n\nBoth facades generate from the same catalog through the same owner-and-kind\nbranching, and the [generator's tests][generator-tests] hold the two to it: a\ncaptured operation forwards purely on both, and a mutation is effect-wrapped on\nthe Cats side only. Nothing Scala has shipped yet, so there is no earlier\nrelease for MiMa or `tasty-mima` to compare against.\n\n## Inherited feature boundaries\n\nThe facade preserves Java's version guards. [Named buffer deletion][buffers]\nrejects tmux before 3.4 because those versions can delete the wrong buffer.\n[`Shell.capturing`][java-shell] rejects tmux 3.3a and 3.4, which lose the\nrequested output. Java's tmux matrix asserts these unsupported results rather\nthan skip the contract or substitute an empty successful result.\n\nCapture and buffer reads retain Java's normalized text, including its handling\nof trailing empty lines. Observations retain decoded text chunks. These APIs\ndo not promise arbitrary-byte round trips. Sparse hook listings preserve\ncommand order without inventing their original indices. Basic copy-mode entry,\ninspection, and exit are wrapped; advanced commands use explicit raw access.\nSee [execution](execution.md) for control acknowledgement limits, and\n[ownership](ownership.md) for resource lifetimes.\n\n[generator]:\n  ../../../build-logic/codegen/src/main/kotlin/io/github/libtmux/codegen/scala/ScalaOperationGenerator.kt\n[generator-tests]:\n  ../../../build-logic/codegen/src/test/kotlin/io/github/libtmux/codegen/scala/ScalaOperationGeneratorTest.kt\n[tmux-matrix]:\n  ../../../build-logic/conventions/src/main/kotlin/libtmux.tmux-matrix.gradle.kts\n[java-options]:\n  ../../../libtmux/src/main/java/io/github/libtmux/Options.java\n[buffers]:\n  ../../../libtmux/src/main/java/io/github/libtmux/Buffers.java\n[java-shell]:\n  ../../../libtmux/src/main/java/io/github/libtmux/Shell.java\n"
+      "content": "# Compatibility\n\nThe Scala facades build, test and publish with the rest of the repository, so\nthey meet the same gates the Java library does.\n\n## Compilers and runtimes\n\nScala 3.9 only — there is no 2.13 build — compiled to JDK 25 bytecode. CI runs\nthe facades' unit suites, their real-tmux suites, the documented Scala examples\nand the runnable programs on JDK 25 and 27 on Linux, and on macOS.\n\nEvery lane of the [tmux matrix][tmux-matrix] runs the real-tmux suites against\nits own tmux: `3.2a`, `3.3`, `3.3a`, `3.4`, `3.5`, `3.6`, `3.7`, `3.7a`, `3.7b`\nand `3.7c`. The Scala fixture takes the lane's tmux the same way the Java one\ndoes.\n\n## Artifacts\n\n- **`libtmux-scala_3`** — direct-style operations and the typed query DSL.\n- **`libtmux-scala-cats_3`** — Cats Effect resources and FS2 observations.\n- **`libtmux-scala-ox_3`** — an Ox `Flow` over subscriptions and live views.\n\nCore's runtime dependencies are the Scala 3 library and `libtmux`. Cats Effect\nand FS2 belong to `libtmux-scala-cats`, Ox to `libtmux-scala-ox`. None depends\non Jackson, JUnit, Kotlin, MCP or the workspace packages.\n\nThe Scala artifacts release with the Java ones, at the same version, in the\nsame Central deployment, signed and attested alike. `libtmux-bom` manages them\ntoo, so one BOM version selects a matching Java and Scala set.\n\n## The generated and handwritten surface\n\nEvery direct-style extension method and Cats per-operation forward that reaches\ntmux is generated from the operation catalog `libtmux` ships, by\n[`ScalaOperationGenerator`][generator] — never hand-copied per method, so it\ncannot drift from what Java exposes. `WAIT`, `STREAM` and `LIFECYCLE`\noperations are written by hand, for their cancellation or resource scoping:\n`Server.open`/`fromJava`/`within`/`control`, `Pane.awaitText`/`run`/`await`,\n`LiveView`, `LiveServer`, and both modules' `Observation`.\n\nBoth facades generate from the same catalog through the same owner-and-kind\nbranching, and the [generator's tests][generator-tests] hold the two to it: a\ncaptured operation forwards purely on both, and a mutation is effect-wrapped on\nthe Cats side only. These alpha artifacts have no binary compatibility\nguarantee; pin an exact version when adding them to an application.\n\n## Inherited feature boundaries\n\nThe facade preserves Java's version guards. [Named buffer deletion][buffers]\nrejects tmux before 3.4 because those versions can delete the wrong buffer.\n[`Shell.capturing`][java-shell] rejects tmux 3.3a and 3.4, which lose the\nrequested output. Java's tmux matrix asserts these unsupported results rather\nthan skip the contract or substitute an empty successful result.\n\nCapture and buffer reads retain Java's normalized text, including its handling\nof trailing empty lines. Observations retain decoded text chunks. These APIs\ndo not promise arbitrary-byte round trips. Sparse hook listings preserve\ncommand order without inventing their original indices. Basic copy-mode entry,\ninspection, and exit are wrapped; advanced commands use explicit raw access.\nSee [execution](execution.md) for control acknowledgement limits, and\n[ownership](ownership.md) for resource lifetimes.\n\n[generator]:\n  ../../../build-logic/codegen/src/main/kotlin/io/github/libtmux/codegen/scala/ScalaOperationGenerator.kt\n[generator-tests]:\n  ../../../build-logic/codegen/src/test/kotlin/io/github/libtmux/codegen/scala/ScalaOperationGeneratorTest.kt\n[tmux-matrix]:\n  ../../../build-logic/conventions/src/main/kotlin/libtmux.tmux-matrix.gradle.kts\n[java-options]:\n  ../../../libtmux/src/main/java/io/github/libtmux/Options.java\n[buffers]:\n  ../../../libtmux/src/main/java/io/github/libtmux/Buffers.java\n[java-shell]:\n  ../../../libtmux/src/main/java/io/github/libtmux/Shell.java\n"
     }
   ]
 }
diff --git a/site/src/layouts/BaseLayout.astro b/site/src/layouts/BaseLayout.astro
index 83673a2a..265f673a 100644
--- a/site/src/layouts/BaseLayout.astro
+++ b/site/src/layouts/BaseLayout.astro
@@ -18,7 +18,7 @@ import { buildTarget } from '../lib/versions'
 import type { VersionEntry } from '../lib/versions'
 import { withPortRoot, withRoot } from '../lib/site-root'
 import { PORT_NAME } from '../lib/api-models'
-import { PORT_BY_SLUG } from '../lib/ports'
+import { PORT_BY_SLUG, portSourceUrl } from '../lib/ports'
 import { markdownPath, type PageSource } from '../lib/markdown-twins'
 import { CONTRIBUTE_BRANCH, CONTRIBUTE_REPO, repoPath } from '../i18n/contribute'
 import type { Locale } from '../i18n/locales'
@@ -125,7 +125,8 @@ const versionEntry: VersionEntry = {
  */
 const section = (pagePath.split('/').filter(Boolean)[0] ?? 'home').toLowerCase()
 
-const navPort = portSlug ?? (process.env.LIBTMUX_DOCS_PORT || undefined) ?? (pagePath.startsWith('reference/') ? pagePath.split('/')[1] : undefined)
+const routePort = portSlug ?? (process.env.LIBTMUX_DOCS_PORT || undefined) ?? (pagePath.startsWith('reference/') ? pagePath.split('/')[1] : undefined)
+const navPort = routePort ? PORT_BY_SLUG[routePort]?.slug : undefined
 const brand = pageBrand(navPort, pagePath)
 let portDefaults: Record<string, string> = {}
 try {
@@ -159,6 +160,11 @@ const llmsRoot = versionRoot && Astro.url.pathname.startsWith(versionRoot) ? ver
 const githubRepo = repository
   ?? (source.repo !== CONTRIBUTE_REPO ? source.repo : undefined)
   ?? ((navPort && PORT_BY_SLUG[navPort]?.repo) || CONTRIBUTE_REPO)
+const githubPort = navPort ? PORT_BY_SLUG[navPort] : undefined
+const githubUrl = githubPort?.source && githubPort.repo === githubRepo
+  ? portSourceUrl(githubPort, target.version,
+      source.repo === githubRepo ? source.ref : process.env.LIBTMUX_DOCS_PORT === navPort ? process.env.LIBTMUX_DOCS_SOURCE_SHA : undefined)
+  : `https://github.com/${githubRepo}/`
 
 ---
 
@@ -269,9 +275,9 @@ const githubRepo = repository
       <div data-pagefind-filter={`section:${section}`} data-pagefind-ignore="all" hidden></div>
       <slot />
     </div>
-    {!bare && <SiteFooter locale={locale as Locale} source={source} markdownHref={markdownHref} llmsRoot={llmsRoot} githubRepo={githubRepo} flush={flush} />}
+    {!bare && <SiteFooter locale={locale as Locale} source={source} markdownHref={markdownHref} llmsRoot={llmsRoot} githubUrl={githubUrl} flush={flush} />}
     <BackToTop />
-    <SearchModal />
+    <SearchModal port={navPort} version={navVersion} />
   </body>
 </html>
 
diff --git a/site/src/lib/docs-paths.ts b/site/src/lib/docs-paths.ts
index 974fde24..0530b650 100644
--- a/site/src/lib/docs-paths.ts
+++ b/site/src/lib/docs-paths.ts
@@ -1,7 +1,17 @@
 /** Collection identity stays distinct from a product page's public path. */
+import { PORT_BY_SLUG } from './ports.ts'
+
+/** Task links stay in the reader's port and version; explicit port links stay explicit. */
+export function proseHref(href: string, root: string, port?: string, version = 'latest'): string {
+  if (!href.startsWith('/') || href.startsWith('//')) return href
+  const section = /^\/(concepts|guides|topics|examples)(?:\/|[?#]|$)/.exec(href)?.[1]
+  const local = port && section && (!PORT_BY_SLUG[port]?.parentLibrary || section === 'concepts')
+  return `${root.replace(/\/+$/, '')}${local ? `/${port}/${version}` : ''}${href}`
+}
+
 export interface DocsPage {
   id: string
-  data: { port?: string; product?: string; route?: string; aliases?: readonly string[] }
+  data: { port?: string; supportedPorts?: readonly string[]; product?: string; route?: string; aliases?: readonly string[] }
 }
 
 /** Path below a port/version root, or the unchanged shared document id. */
diff --git a/site/src/lib/llms.ts b/site/src/lib/llms.ts
index 48ae3e9d..217e9bf0 100644
--- a/site/src/lib/llms.ts
+++ b/site/src/lib/llms.ts
@@ -1,36 +1,18 @@
 /**
- * The `llms.txt` family, built from the same content collection the pages are.
- *
- * `notes/research/10-llms-and-agents.md` sets the rule this follows: machine-
- * readable output must come from the *resolved* content, never from doc-comment
- * source. For the shell that is easy — its prose is hand-written Markdown, so
- * source and resolved content are the same text — and it is the reason these
- * files are generated here rather than by a post-build HTML-to-Markdown pass.
- *
- * What is genuinely new is that a per-port build gets a per-port file. The
- * remark plugin drops other ports' fences from the HTML; this does the same to
- * the Markdown, so `/py/stable/llms-full.txt` carries Python and no other
- * language. An agent pointed at one port's documentation gets one port's code,
- * which is the whole point of the per-language mechanism applied to the one
- * consumer that cannot see the language switcher.
- *
- * Scope, stated rather than implied: the generated API reference is indexed in
- * `llms.txt` but not inlined into `llms-full.txt`. .NET's reference alone is
- * 1.5 MB of Markdown across 215 files, which would make the full-text file
- * useless for the context windows it exists to fit into. Agents that want it
- * can follow the URL.
+ * LLM exports use the HTML renderer's port selection and example sources.
+ * API references are linked, rather than inlined into the full prose export.
  */
 import { getCollection } from 'astro:content'
 import type { CollectionEntry } from 'astro:content'
-import { LANG_TO_PORT, parseMeta, readFence } from '../plugins/remark-port-code.mjs'
+import { resolvePortCode } from '../plugins/remark-port-code.mjs'
 import { PORTS, PORT_BY_SLUG, hasReference, portPageUrl, productApiPath, productAvailable, referenceUrl, workspaceOverviewNotice } from './ports.ts'
 import { DEFAULT_LOCALE } from '../i18n/locales.ts'
 import { buildLocale, localeOf, sourceIdOf } from '../i18n/resolve.ts'
 import { buildTarget } from './versions.ts'
-import { docsPath, docsRoutePath, type DocsPage } from './docs-paths.ts'
+import { docsPath, docsRoutePath, proseHref, type DocsPage } from './docs-paths.ts'
 import { docsEntryAvailable } from './page-port-links.ts'
 import type { Locale } from '../i18n/locales.ts'
-import { PORT_ROOT } from './site-root.ts'
+import { PORT_ROOT, SITE_ROOT } from './site-root.ts'
 import { API_MODELS } from './api-models.ts'
 import { productApiHref, productApiRoots } from './product-api.ts'
 
@@ -43,60 +25,6 @@ export interface LlmsPage {
   body: string
 }
 
-/**
- * Turn a page's Markdown *source* into the Markdown a reader of this build
- * would actually see: other ports' fences dropped, `file=` fences filled in.
- *
- * Both halves matter, and the second is the one that is easy to forget.
- * `entry.body` is source, and a `file="examples/capture/capture.ts"` fence has
- * an empty body in source — the remark plugin reads the checkout while
- * rendering HTML. Concatenating source into llms-full.txt would therefore ship
- * a file whose TypeScript examples are all blank, which is exactly the
- * source-versus-resolved bug notes/research/10-llms-and-agents.md was written
- * about. So this calls the same reader the plugin does.
- *
- * A line scan rather than an AST walk on purpose: Astro has already parsed
- * this text once, and re-parsing it to delete four lines is the more fragile
- * of the two. Nested fences are the one thing a scanner gets wrong, and the
- * docs collection has none.
- */
-export function resolvePortCode(body: string, port: string | undefined): string {
-  const lines = body.split('\n')
-  const out: string[] = []
-  let inFence = false
-  // Drop this fence entirely (it belongs to another port), or drop just its
-  // source body (the plugin replaces it with the file's contents).
-  let dropping = false
-  let replaced = false
-  for (const line of lines) {
-    const fence = line.match(/^```(\S*)(.*)$/)
-    if (fence && !inFence) {
-      inFence = true
-      const owner = LANG_TO_PORT[fence[1].toLowerCase()]
-      dropping = Boolean(port) && Boolean(owner) && owner !== port
-      replaced = false
-      if (dropping) continue
-      out.push(line)
-      const meta = parseMeta(fence[2])
-      if (meta.file && owner) {
-        out.push(readFence(owner, meta, 'llms-full.txt'))
-        replaced = true
-      }
-      continue
-    }
-    if (fence && inFence) {
-      inFence = false
-      const wasDropping = dropping
-      dropping = false
-      replaced = false
-      if (!wasDropping) out.push(line)
-      continue
-    }
-    if (!dropping && !replaced) out.push(line)
-  }
-  return out.join('\n').replace(/\n{3,}/g, '\n\n')
-}
-
 /** Section label for grouping, falling back to the top path segment. */
 function sectionOf(entry: CollectionEntry<'docs'>): string {
   const group = entry.data.sidebar?.group
@@ -150,7 +78,13 @@ export function llmsPage(entry: CollectionEntry<'docs'>, origin: string, base: s
   try { defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}') } catch { /* Local defaults are latest. */ }
   const entryPort = entry.data.port
   const version = port ? buildTarget(process.env).version : (defaults[entryPort ?? ''] ?? 'latest')
-  let body = resolvePortCode(entry.body ?? '', entryPort ? undefined : port)
+  const path = docsRoutePath(entry, port, defaults)
+  const url = `${origin}${entry.data.product && !port ? `${PORT_ROOT}/` : base}${path ? `${path}/` : ''}`
+  let body = resolvePortCode(entry.body ?? '', port, entryPort,
+    (href: string) => new URL(proseHref(href, SITE_ROOT, entryPort ?? port, version), url).href)
+  if (entry.data.cards?.length) {
+    body += `\n\n${entry.data.cards.map((card) => `- [${card.label}](${new URL(card.href, url).href}): ${card.body}`).join('\n')}\n`
+  }
   if (entryPort && entry.data.product === 'workspace' && docsPath(entry) === 'workspace') {
     const notice = workspaceOverviewNotice(PORT_BY_SLUG[entryPort])
     if (notice) body = `**${notice.title}** ${notice.body}\n\n${body}`
@@ -163,11 +97,10 @@ export function llmsPage(entry: CollectionEntry<'docs'>, origin: string, base: s
     if (entry.data.product === 'mcp') body += `\n[Protocol catalog](${origin}${portPageUrl(PORT_BY_SLUG[entryPort], version, 'mcp/tools').replace(/\/$/, '.json')})\n`
   }
   // A locale's landing entry routes to '', which is the root itself.
-  const path = docsRoutePath(entry, port, defaults)
   return {
     title: entry.data.title,
     description: entry.data.description ?? '',
-    url: `${origin}${entry.data.product && !port ? `${PORT_ROOT}/` : base}${path ? `${path}/` : ''}`,
+    url,
     section: sectionOf(entry),
     body,
     order: entry.data.sidebar?.order ?? Number.MAX_SAFE_INTEGER,
diff --git a/site/src/lib/page-port-links.ts b/site/src/lib/page-port-links.ts
index 7ea6d952..1b52efba 100644
--- a/site/src/lib/page-port-links.ts
+++ b/site/src/lib/page-port-links.ts
@@ -31,6 +31,7 @@ export interface PagePortLink {
 
 /** Matches the port restriction used by the prose route. */
 export function docsEntryAvailable(entry: DocsPage, port?: string): boolean {
+  if (port && entry.data.supportedPorts && !entry.data.supportedPorts.includes(port)) return false
   if (port && PORT_BY_SLUG[port]?.parentLibrary) {
     if (entry.data.product) return false
     const first = entry.id.split('/')[0]
@@ -63,7 +64,9 @@ export function pagePortLinks({
     : undefined
   const symbolPort = portSlug
   const alternatives = symbol ? referenceAlternatives(symbolPort!, symbol.publicId ?? symbol.id) : []
-  const entries = docs.filter((entry) => docsPath(entry) === path)
+  const own = docs.find((entry) => entry.data.port === portSlug && docsPath(entry) === path)
+  const paths = [path, ...(own?.data.aliases ?? [])]
+  const entries = paths.flatMap((candidate) => docs.filter((entry) => docsPath(entry) === candidate || entry.data.aliases?.includes(candidate)))
   const tool = path.startsWith('mcp/tools/') && portSlug
     ? MCP_REFERENCE[portSlug]?.registrations.find((entry) => entry.wireName === path.slice('mcp/tools/'.length)) : undefined
 
@@ -98,8 +101,12 @@ export function pagePortLinks({
       if (target) links = [{ href: portPageUrl(port, targetVersion, `mcp/tools/${target.wireName}`) }]
     } else if (path === 'mcp/tools') {
       if (productAvailable(port, 'mcp')) links = [{ href: portPageUrl(port, targetVersion, path) }]
-    } else if ((!port.parentLibrary && (SHARED_PAGE_PATHS as readonly string[]).includes(path)) || entries.some((entry) => docsEntryAvailable(entry, port.slug))) {
+    } else if (!port.parentLibrary && (SHARED_PAGE_PATHS as readonly string[]).includes(path)) {
       links = [{ href: portPageUrl(port, targetVersion, path) }]
+    } else {
+      const target = entries.find((entry) => entry.data.port === port.slug && docsEntryAvailable(entry, port.slug))
+        ?? entries.find((entry) => docsEntryAvailable(entry, port.slug))
+      if (target) links = [{ href: portPageUrl(port, targetVersion, docsPath(target)) }]
     }
     return { port: port.slug, name: port.name, links }
   })
diff --git a/site/src/lib/port-documentation.ts b/site/src/lib/port-documentation.ts
index 4bb34bdb..2c02ded2 100644
--- a/site/src/lib/port-documentation.ts
+++ b/site/src/lib/port-documentation.ts
@@ -63,7 +63,7 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
     domains: [libraryDomain('Kotlin coroutine handles, builders and flows over the Java/JVM library.')],
     sourceGuides: [
       guide('libtmux-kotlin/README.md', 'guides/getting-started', 'core'),
-      guide('docs/guide/kotlin.md', 'guides/coroutines', 'core'),
+      guide('docs/guide/kotlin.md', 'guides/coroutines', 'core', { aliases: ['guides/source/coroutines', 'concepts/transports'] }),
     ],
   },
   scala: {
@@ -71,7 +71,9 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
     sourceGuides: [
       guide('libtmux-scala/README.md', 'guides/overview', 'core'),
       ...['getting-started', 'query', 'ownership', 'execution', 'streaming', 'compatibility'].map((name) =>
-        guide(`docs/guide/scala/${name}.md`, `guides/${name}`, 'core')),
+        guide(`docs/guide/scala/${name}.md`, `guides/${name}`, 'core', {
+          aliases: [`guides/source/${name}`, ...(name === 'execution' ? ['concepts/transports'] : [])],
+        })),
     ],
   },
   fsharp: {
@@ -79,7 +81,9 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
     sourceGuides: [
       guide('src/LibTmux.FSharp/README.md', 'guides/quickstart', 'core'),
       ...['getting-started', 'queries', 'streams', 'interop', 'modes', 'supported-query-fields'].map((name) =>
-        guide(`docs/fsharp/${name}.md`, `guides/${name}`, 'core')),
+        guide(`docs/fsharp/${name}.md`, `guides/${name}`, 'core', {
+          aliases: [`guides/source/${name}`, ...(name === 'modes' ? ['concepts/transports'] : [])],
+        })),
       guide('docs/fsharp/api.md', 'reference', 'core', { aliases: [], sidebar: { group: 'API reference' } }),
     ],
   },
@@ -103,9 +107,9 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
       },
     ],
     sourceGuides: [
-      guide('README.md', 'guides/overview', 'core'),
-      guide('docs/modes.md', 'guides/execution-modes', 'core'),
-      guide('docs/ownership-errors.md', 'guides/ownership-errors', 'core'),
+      guide('README.md', 'guides/overview', 'core', { aliases: ['guides/source/overview', 'guides/getting-started'] }),
+      guide('docs/modes.md', 'guides/execution-modes', 'core', { aliases: ['guides/source/execution-modes', 'concepts/transports'] }),
+      guide('docs/ownership-errors.md', 'guides/ownership-errors', 'core', { aliases: ['guides/source/ownership-errors', 'topics/context-managers', 'topics/errors-and-exceptions'] }),
       guide('docs/recipes.md', 'examples/recipes', 'core', { aliases: ['examples/source-recipes'] }),
       guide('gems/libtmux/README.md', 'guides/core', 'core', { package: 'core', sidebar: { group: 'Core library' } }),
       guide('gems/libtmux-async/README.md', 'guides/async', 'async', { package: 'async', sidebar: { group: 'Async' } }),
@@ -133,19 +137,19 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
       },
     ],
     sourceGuides: [
-      guide('README.md', 'guides/overview', 'core'),
+      guide('README.md', 'guides/overview', 'core', { aliases: ['guides/source/overview', 'guides/getting-started'] }),
       guide('docs/runtime.md', 'guides/runtime', 'runtime', { sidebar: { group: 'Runtime adapters', label: 'luv and Neovim' } }),
-      guide('docs/query.md', 'guides/query', 'core'),
+      guide('docs/query.md', 'guides/query', 'core', { aliases: ['guides/source/query', 'concepts/queries', 'guides/querying-and-filtering'] }),
       guide('docs/snapshots.md', 'guides/snapshots', 'core'),
       guide('docs/creation.md', 'guides/creation', 'core'),
       guide('docs/topology.md', 'guides/topology', 'core'),
-      guide('docs/panes.md', 'guides/panes', 'core'),
-      guide('docs/control.md', 'guides/control', 'core'),
+      guide('docs/panes.md', 'guides/panes', 'core', { aliases: ['guides/source/panes', 'topics/pane-interaction', 'guides/capturing-output', 'guides/sending-keys'] }),
+      guide('docs/control.md', 'guides/control', 'core', { aliases: ['guides/source/control', 'concepts/transports'] }),
       guide('docs/commands.md', 'guides/commands', 'core'),
       guide('docs/buffers.md', 'guides/buffers', 'core'),
       guide('docs/clients.md', 'guides/clients', 'core'),
-      guide('docs/environment.md', 'guides/environment', 'core'),
-      guide('docs/settings.md', 'guides/settings', 'core'),
+      guide('docs/environment.md', 'guides/environment', 'core', { aliases: ['guides/source/environment', 'topics/environment'] }),
+      guide('docs/settings.md', 'guides/settings', 'core', { aliases: ['guides/source/settings', 'topics/options-and-hooks'] }),
       guide('docs/fields.md', 'guides/fields', 'core'),
       guide('docs/options-reference.md', 'guides/options', 'core'),
       guide('docs/compatibility.md', 'guides/compatibility', 'core'),
diff --git a/site/src/lib/ports.ts b/site/src/lib/ports.ts
index 49c85aa9..d569e2fc 100644
--- a/site/src/lib/ports.ts
+++ b/site/src/lib/ports.ts
@@ -153,6 +153,8 @@ export interface Port {
   packageName: string
   /** Source repository, `owner/name`. */
   repo: string
+  /** Library directory and default branch for browser links within a repository. */
+  source?: PortPackage['source']
   /** Working checkout, for the build script. Tilde-relative. */
   checkout: string
   /** Where the docs-branch worktree lives. Tilde-relative. */
@@ -1001,6 +1003,7 @@ const WRAPPER_LIBRARIES: readonly WrapperLibrary[] = [
   {
     slug: 'kotlin', logoLanguage: 'kotlin', shortName: 'Kt', name: 'Kotlin', language: 'Kotlin',
     parentLibrary: { slug: 'java', runtime: 'JVM' },
+    source: { path: 'libtmux-kotlin', ref: 'master' },
     packageName: 'io.github.libtmux:libtmux-kotlin',
     registry: { name: 'Maven Central', url: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin', icon: 'maven' },
     ecosystemHost: { name: 'Dokka', url: 'https://javadoc.io/doc/io.github.libtmux/libtmux-kotlin', rationale: 'Kotlin API documentation from the Dokka archive published with the package.' },
@@ -1018,6 +1021,7 @@ const WRAPPER_LIBRARIES: readonly WrapperLibrary[] = [
   {
     slug: 'scala', logoLanguage: 'scala', shortName: 'Sc', name: 'Scala', language: 'Scala',
     parentLibrary: { slug: 'java', runtime: 'JVM' },
+    source: { path: 'libtmux-scala', ref: 'master' },
     packageName: 'io.github.libtmux:libtmux-scala_3',
     registry: { name: 'Maven Central', url: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-scala_3', icon: 'maven' },
     ecosystemHost: { name: 'Scaladoc', url: 'https://javadoc.io/doc/io.github.libtmux/libtmux-scala_3', rationale: 'Scala 3 API documentation from the Scaladoc archive published with the package.' },
@@ -1066,6 +1070,15 @@ export const PORT_BY_SLUG: Readonly<Record<string, Port>> = Object.fromEntries(
   PORTS.map((p) => [p.slug, p]),
 )
 
+/** Open a library's directory at its documented revision, tag, or default branch. */
+export function portSourceUrl(port: Port, version = 'latest', revision?: string): string {
+  const root = `https://github.com/${port.repo}`
+  if (!port.source) return root
+  const tag = /^v?\d/.test(version) ? `${port.tagPrefix ?? ''}${version}` : undefined
+  const ref = revision ?? tag ?? port.source.ref
+  return `${root}/tree/${encodeURIComponent(ref)}/${port.source.path}`
+}
+
 /** Whether a companion product has a published implementation for a port. */
 export function productAvailable(port: Port, product: DocProduct): boolean {
   return !port.parentLibrary && port.productAvailability?.[product] !== 'unpublished'
@@ -1094,15 +1107,14 @@ export function workspaceOverviewNotice(port: Port): { title: string; body: stri
     return {
       title,
       body: `The \`tmux-workspace\` CLI is published to ${port.registry?.name ?? 'the package registry'} `
-        + 'as a prerelease. Its command and configuration coverage is partial.',
+        + 'as a prerelease. Pin its version when automation depends on its output.',
     }
   }
   if (port.workspaceCliAvailability !== 'local') return undefined
   return {
     title,
-    body: 'The local `workspace-cli` checkout contains a `tmux-workspace` CLI with native services. '
-      + 'This implementation is partial and unreleased; published library packages do '
-      + 'not provide this local CLI checkpoint.',
+    body: 'Build `tmux-workspace` from the source revision in the installation guide. '
+      + 'Its CLI and workspace library have separate installation and configuration contracts.',
   }
 }
 
@@ -1110,9 +1122,9 @@ export function productDescription(port: Port, product: DocProduct): string {
   if (!productAvailable(port, product)) return 'Not available for this language port.'
   if (product === 'workspace') {
     if (port.workspaceCliAvailability === 'local')
-      return `The local workspace-cli worktree provides ${port.workspaceCli}. Command and configuration coverage is incomplete.`
+      return `Build the CLI from source and load workspace files with ${port.workspaceCli}.`
     if (port.workspaceCliAvailability === 'published')
-      return `The published prerelease provides ${port.workspaceCli}. Command and configuration coverage is incomplete.`
+      return `Load workspace files with the ${port.workspaceCli} prerelease.`
     return port.workspaceCli
       ? `Load workspace configuration files with ${port.workspaceCli}.`
       : 'In development. Workspace builder internals; no workspace loader CLI.'
diff --git a/site/src/lib/quickstarts.ts b/site/src/lib/quickstarts.ts
index 66f306b2..9b08da41 100644
--- a/site/src/lib/quickstarts.ts
+++ b/site/src/lib/quickstarts.ts
@@ -26,8 +26,8 @@ function documentedRegion(source: string, name: string): string {
   return selected.map((line) => line.slice(Math.min(indent, line.length))).join('\n')
 }
 
-const rubyQuickstart = documentedRegion(EXAMPLE_SOURCES['ruby:examples/quickstart.rb'], 'main')
-const luaQuickstart = documentedRegion(EXAMPLE_SOURCES['lua:examples/quickstart.lua'], 'main')
+const rubyQuickstart = documentedRegion(EXAMPLE_SOURCES['ruby:examples/quickstart.rb'].content, 'main')
+const luaQuickstart = documentedRegion(EXAMPLE_SOURCES['lua:examples/quickstart.lua'].content, 'main')
 
 /** Quote a block checked by the parent repository's documentation tests. */
 function guideExample(artifact: typeof KOTLIN_GUIDES, path: string, heading: string, lang: string): Quickstart {
@@ -59,7 +59,7 @@ export const QUICKSTARTS: Partial<Record<string, Quickstart>> = {
   },
   fsharp: {
     lang: 'fsharp',
-    code: EXAMPLE_SOURCES['fsharp:examples/LibTmux.FSharp.Quickstart/Program.fs']
+    code: EXAMPLE_SOURCES['fsharp:examples/LibTmux.FSharp.Quickstart/Program.fs'].content
       .replace(/^\/\/ fsharp-snippet: Quickstart\n/, '').replace(/\n\/\/ endfsharp-snippet\n?$/, ''),
     source: 'From examples/LibTmux.FSharp.Quickstart/Program.fs. The package consumer check runs this exact program against the packed LibTmux.FSharp artifact on .NET 8 and 10.',
   },
diff --git a/site/src/lib/search-panel.ts b/site/src/lib/search-panel.ts
index bfda1674..f73fbd74 100644
--- a/site/src/lib/search-panel.ts
+++ b/site/src/lib/search-panel.ts
@@ -43,6 +43,8 @@ export interface SearchPanelOptions {
   subResults?: SubResultsDisplay
   /** A query to run as soon as the panel mounts. */
   initialQuery?: string
+  /** Select the current port before the first query; readers may change it. */
+  initialPort?: string
   /** An index to search instead of Pagefind's. */
   mock?: PagefindApi
   /** Names for path segments in a breadcrumb, such as `py` for Python. */
@@ -80,6 +82,7 @@ export function mountSearchPanel(root: HTMLElement, bundlePath: string, settings
   let all: { id: string; data: () => Promise<PagefindResultData> }[] = []
   let selected = -1
   let token = 0
+  const selectedPorts = new Set(settings.initialPort ? [settings.initialPort] : [])
 
   const status = (text: string) => {
     results.innerHTML = ''
@@ -115,32 +118,32 @@ export function mountSearchPanel(root: HTMLElement, bundlePath: string, settings
   }
 
   const activeFilters = () => {
-    const checked = [...filterList.querySelectorAll<HTMLInputElement>('input:checked')].map(
-      (i) => i.value,
-    )
+    const checked = [...selectedPorts]
     return checked.length ? { port: checked } : undefined
   }
 
   async function renderFilters(counts: Record<string, number> | undefined) {
-    if (!counts || Object.keys(counts).length === 0) {
+    const available = { ...Object.fromEntries([...selectedPorts].map((port) => [port, 0])), ...counts }
+    if (Object.keys(available).length === 0) {
       filtersBox.hidden = true
       return
     }
     // Open, not collapsed. The filter is how a reader narrows twelve thousand
     // symbols to one port, and behind a closed disclosure it went unused.
     filtersBox.hidden = false
-    const previous = new Set(
-      [...filterList.querySelectorAll<HTMLInputElement>('input:checked')].map((i) => i.value),
-    )
     filterList.innerHTML = ''
-    for (const [value, count] of Object.entries(counts).sort((a, b) => b[1] - a[1])) {
+    for (const [value, count] of Object.entries(available).sort((a, b) => b[1] - a[1])) {
       const label = document.createElement('label')
       label.className = 'search-panel__filter'
       const box = document.createElement('input')
       box.type = 'checkbox'
       box.value = value
-      box.checked = previous.has(value)
-      box.addEventListener('change', () => void run(input.value))
+      box.checked = selectedPorts.has(value)
+      box.addEventListener('change', () => {
+        if (box.checked) selectedPorts.add(value)
+        else selectedPorts.delete(value)
+        void run(input.value)
+      })
       const text = document.createElement('span')
       text.textContent = value
       const n = document.createElement('span')
@@ -257,8 +260,10 @@ export function mountSearchPanel(root: HTMLElement, bundlePath: string, settings
   }
 
   async function paint() {
+    const mine = token
     const slice = all.slice(0, shown)
     const rendered = await Promise.all(slice.map((r) => r.data()))
+    if (mine !== token) return
     results.innerHTML = ''
 
     const count = document.createElement('p')
@@ -325,7 +330,10 @@ export function mountSearchPanel(root: HTMLElement, bundlePath: string, settings
       selected = -1
       status('Type to search.')
       const idle = await pagefind()
-      if (idle && mine === token) await renderFilters((await idle.filters()).port)
+      if (idle && mine === token) {
+        const counts = await idle.filters()
+        if (mine === token) await renderFilters(counts.port)
+      }
       return
     }
 
diff --git a/site/src/lib/workspace-shared-slots.ts b/site/src/lib/workspace-shared-slots.ts
index 5ff36acc..bf0bfc91 100644
--- a/site/src/lib/workspace-shared-slots.ts
+++ b/site/src/lib/workspace-shared-slots.ts
@@ -1,13 +1,5 @@
-/**
- * Pure text operations behind the shared-workspace-page mechanism.
- *
- * Dependency-free on purpose: `site/src/loaders/workspace-shared.ts` (the
- * Astro content loader) and `scripts/gen-mentions.mjs` (a plain-Node
- * filesystem scanner outside the site's own dependency resolution root, see
- * that script's comment) both import this module directly by relative path.
- * Neither `astro` nor any of its markdown helpers are reachable from
- * `scripts/`, so nothing here may depend on them.
- */
+/** Content ownership shared by rendering, Markdown exports and source scanners. */
+import { PORTS } from './ports.ts'
 
 /**
  * Ports the generic, unreleased native `tmux-workspace` CLI documentation
@@ -18,7 +10,30 @@
  */
 export const KNOWN_PORTS = new Set(['py', 'ts', 'rs', 'go', 'java', 'dotnet', 'cxx', 'swift'])
 
-const SLOT_TAG = /<!--\s*port:([a-z0-9,\s-]+?)\s*-->|<!--\s*\/port\s*-->/gi
+const CONTENT_PORTS = new Set([...PORTS.map((port) => port.slug), 'root'])
+const SLOT_TAG = /<!--\s*port:([\s\S]*?)-->|<!--\s*\/port\s*-->/gi
+
+/** Markdown examples can show ownership syntax literally; other fences may contain slots. */
+function fencedRanges(raw: string): [number, number][] {
+  const ranges: [number, number][] = []
+  let fence: { marker: string; length: number; start: number; literal: boolean } | undefined
+  let offset = 0
+  for (const line of raw.split(/(?<=\n)/)) {
+    const match = /^ {0,3}(`{3,}|~{3,})(.*)/.exec(line.replace(SLOT_TAG, ''))
+    if (match) {
+      const [, marker, rest] = match
+      if (!fence && !(marker[0] === '`' && rest.includes('`'))) {
+        fence = { marker: marker[0], length: marker.length, start: offset, literal: /^(?:markdown|md)\b/.test(rest.trim()) }
+      } else if (fence && marker[0] === fence.marker && marker.length >= fence.length && !rest.trim()) {
+        if (fence.literal) ranges.push([fence.start, offset + line.length])
+        fence = undefined
+      }
+    }
+    offset += line.length
+  }
+  if (fence?.literal) ranges.push([fence.start, raw.length])
+  return ranges
+}
 
 export interface SlotNode {
   /** `null` for the implicit root, which every port keeps. */
@@ -30,12 +45,24 @@ export interface SlotNode {
 export function parseSlots(raw: string): SlotNode {
   const root: SlotNode = { ports: null, children: [] }
   const stack: SlotNode[] = [root]
+  const fences = fencedRanges(raw)
   let last = 0
   for (const m of raw.matchAll(SLOT_TAG)) {
-    const idx = m.index ?? 0
+    let idx = m.index ?? 0
+    if (fences.some(([start, end]) => idx >= start && idx < end)) continue
+    let end = idx + m[0].length
+    const lineStart = raw.lastIndexOf('\n', idx - 1) + 1
+    const newline = raw.indexOf('\n', end)
+    const lineEnd = newline < 0 ? raw.length : newline
+    // A directive on its own line contributes no Markdown blank line. This
+    // keeps scoped table rows contiguous in both root and port documents.
+    if (!raw.slice(lineStart, idx).trim() && !raw.slice(end, lineEnd).trim()) {
+      idx = lineStart
+      end = newline < 0 ? raw.length : newline + 1
+    }
     const text = raw.slice(last, idx)
     if (text) stack[stack.length - 1]!.children.push(text)
-    last = idx + m[0].length
+    last = end
     if (m[1] !== undefined) {
       const ports = new Set(
         m[1]
@@ -43,9 +70,10 @@ export function parseSlots(raw: string): SlotNode {
           .map((p) => p.trim())
           .filter(Boolean),
       )
+      if (!ports.size) throw new Error('port-content: empty port list')
       for (const port of ports) {
-        if (!KNOWN_PORTS.has(port)) {
-          throw new Error(`workspace-shared: unknown port "${port}" in <!-- port:${m[1]} -->`)
+        if (!CONTENT_PORTS.has(port)) {
+          throw new Error(`port-content: unknown port "${port}" in <!-- port:${m[1]} -->`)
         }
       }
       const node: SlotNode = { ports, children: [] }
@@ -62,15 +90,38 @@ export function parseSlots(raw: string): SlotNode {
   return root
 }
 
-/** Render a slot tree for one port: drop every node whose ports exclude it. */
-export function resolveSlots(node: SlotNode, port: string): string {
-  if (node.ports && !node.ports.has(port)) return ''
+/** Root pages keep all languages; a port keeps only its own regions. */
+export function resolveSlots(node: SlotNode, port?: string): string {
+  if (port && node.ports && !node.ports.has(port)) return ''
   return node.children.map((child) => (typeof child === 'string' ? child : resolveSlots(child, port))).join('')
 }
 
+/** Resolve ownership and retain the context needed to link root-page API names. */
+export function resolvePortContent(raw: string, port?: string): { body: string; portAt: (offset: number) => string | undefined } {
+  const parts: string[] = []
+  const regions: { start: number; end: number; port: string }[] = []
+  let offset = 0
+  const append = (node: SlotNode, inherited?: string) => {
+    if (port && node.ports && !node.ports.has(port)) return
+    const owners = node.ports && [...node.ports].filter((owner) => owner !== 'root')
+    const owner = owners?.length ? (owners.length === 1 ? owners[0] : undefined) : inherited
+    for (const child of node.children) {
+      if (typeof child !== 'string') { append(child, owner); continue }
+      parts.push(child)
+      if (owner) regions.push({ start: offset, end: offset + child.length, port: owner })
+      offset += child.length
+    }
+  }
+  append(parseSlots(raw))
+  return {
+    body: parts.join(''),
+    portAt: (position) => regions.find(({ start, end }) => position >= start && position < end)?.port,
+  }
+}
+
 /** Resolve a shared page's raw body to the text one port renders. */
-export function resolvePortBody(raw: string, port: string): string {
-  return resolveSlots(parseSlots(raw), port)
+export function resolvePortBody(raw: string, port?: string): string {
+  return resolvePortContent(raw, port).body
 }
 
 export interface SharedFrontmatter {
diff --git a/site/src/loaders/workspace-shared.ts b/site/src/loaders/workspace-shared.ts
index c29f04e7..eee93a09 100644
--- a/site/src/loaders/workspace-shared.ts
+++ b/site/src/loaders/workspace-shared.ts
@@ -89,6 +89,16 @@ export function workspaceDocsLoader(): Loader {
   return {
     name: 'workspace-docs',
     load: async (context: LoaderContext) => {
+      // Astro's glob loader logs Markdown failures and keeps loading. Reject
+      // invalid ownership before that catch can turn a broken page into a build.
+      const docsDir = fileURLToPath(new URL(DOCS_BASE, context.config.root))
+      for (const file of await walkMarkdown(docsDir)) {
+        try {
+          resolvePortBody(await readFile(file, 'utf8'))
+        } catch (cause) {
+          throw new Error(`Invalid port content in ${relative(docsDir, file)}`, { cause })
+        }
+      }
       // Delegate first: glob() clears any store id it did not touch, so the
       // synthetic entries below must be written after it returns, not before.
       await glob({ base: DOCS_BASE, pattern: DOCS_PATTERN }).load(context)
diff --git a/site/src/pages/[...slug].astro b/site/src/pages/[...slug].astro
index a46e7ba3..a4bb2a7e 100644
--- a/site/src/pages/[...slug].astro
+++ b/site/src/pages/[...slug].astro
@@ -45,7 +45,8 @@ export async function getStaticPaths() {
       .map(({ path, target }) => ({ params: { slug: path }, props: { redirect: target } }))
     const routes = [...real, ...global, ...reference, ...protocol, ...redirects]
     const paths = routes.map((route) => route.params.slug)
-    if (new Set(paths).size !== paths.length) throw new Error('Duplicate generated documentation route')
+    const duplicates = paths.filter((path, index) => paths.indexOf(path) !== index)
+    if (duplicates.length) throw new Error(`Duplicate generated documentation routes: ${[...new Set(duplicates)].join(', ')}`)
     return routes
   }
   const placeholders = (await placeholderPairs())
diff --git a/site/src/pages/docs.json.ts b/site/src/pages/docs.json.ts
index 448c83ff..729b4faa 100644
--- a/site/src/pages/docs.json.ts
+++ b/site/src/pages/docs.json.ts
@@ -10,6 +10,7 @@ import { docsEntryAvailable } from '../lib/page-port-links.ts'
 import { isIndexSource, markdownPath } from '../lib/markdown-twins.ts'
 import { localeProse } from '../lib/llms.ts'
 import { documentationAreas } from '../lib/port-documentation.ts'
+import { buildTarget } from '../lib/versions.ts'
 
 /**
  * `/docs.json` — the agent manifest.
@@ -39,9 +40,10 @@ export const GET: APIRoute = async ({ site }) => {
   // trailing slash; every use below joins a path that has no leading one.
   const refBase = `${PORT_ROOT}/`
   const port = process.env.LIBTMUX_DOCS_PORT
+  const visiblePorts = PORTS.filter((entry) => !port || entry.slug === port)
   const locale = buildLocale()
-  let defaults: Record<string, string> = {}
-  try { defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}') } catch { /* Local defaults are latest. */ }
+  const defaults: Record<string, string> = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
+  const versionFor = (slug: string) => slug === port ? buildTarget(process.env).version : (defaults[slug] ?? 'latest')
 
   const entries = await getCollection(
     'docs',
@@ -76,17 +78,18 @@ export const GET: APIRoute = async ({ site }) => {
 
   // The reference is not in the docs collection, and an agent asking "what is
   // documented here" should not be told only about the prose.
-  for (const [port, model] of Object.entries(API_MODELS)) {
+  for (const [slug, model] of Object.entries(API_MODELS)) {
+    if (port && slug !== port) continue
     const types = ownersOf(model)
     pages.push({
-      title: `${PORT_NAME[port] ?? port} API reference`,
+      title: `${PORT_NAME[slug] ?? slug} API reference`,
       description: `${model.symbols.length} symbols extracted from source, ${types.length} with their own page.`,
       section: 'API reference',
       // refBase, not base: the reference is generated in the default locale
       // only, so a Japanese manifest advertising a locale-prefixed reference
       // names pages nothing builds.
-      url: `${origin}${refBase}${port}/${defaults[port] ?? 'latest'}/reference/`,
-      markdownUrl: `${origin}${refBase}${port}/${defaults[port] ?? 'latest'}/reference/index.md`,
+      url: `${origin}${refBase}${slug}/${versionFor(slug)}/reference/`,
+      markdownUrl: `${origin}${refBase}${slug}/${versionFor(slug)}/reference/index.md`,
       headings: types.slice(0, 200).map((t) => ({
         id: t.publicId ?? t.id,
         level: 2,
@@ -96,9 +99,10 @@ export const GET: APIRoute = async ({ site }) => {
   }
 
   const manifest = {
-    name: 'libtmux',
+    name: port ? `libtmux for ${PORT_BY_SLUG[port].name}` : 'libtmux',
     url: `${origin}${base}`,
-    description: `Typed tmux control libraries for ${PORTS.map((port) => port.name).join(', ')}, documented as one site.`,
+    description: port ? `Guides, examples and API reference for ${PORT_BY_SLUG[port].packageName}.`
+      : `Typed tmux control libraries for ${PORTS.map((port) => port.name).join(', ')}, documented as one site.`,
     sourceRepository: `https://github.com/${port ? PORT_BY_SLUG[port].repo : 'tmux-python/libtmux'}`,
     agentEntrypoints: {
       manifest: `${base}docs.json`,
@@ -109,31 +113,31 @@ export const GET: APIRoute = async ({ site }) => {
       // matters most for an agent that already speaks Sphinx.
       inventory: `${refBase}objects.inv`,
     },
-    ports: PORTS.map((p) => ({
+    ports: visiblePorts.map((p) => ({
       slug: p.slug,
       name: p.name,
       language: p.language,
       referenceKind: p.referenceKind ?? 'model',
       package: p.packageName,
-      reference: hasReference(p) ? referenceUrl(p, defaults[p.slug] ?? 'latest') : null,
+      reference: hasReference(p) ? referenceUrl(p, versionFor(p.slug)) : null,
       ...(p.parentLibrary ? { parentLibrary: p.parentLibrary } : {}),
       products: Object.entries(p.parentLibrary ? {} : DOC_PRODUCTS).map(([slug, product]) => ({
         slug, name: product.label,
         availability: productAvailable(p, slug as DocProduct) ? 'available' : 'unpublished',
         inDevelopment: productInDevelopment(p, slug as DocProduct),
         ...(slug === 'workspace' ? { cli: p.workspaceCli ?? null, cliAvailability: p.workspaceCliAvailability ?? null } : {}),
-        url: portPageUrl(p, defaults[p.slug] ?? 'latest', slug),
+        url: portPageUrl(p, versionFor(p.slug), slug),
         reference: productAvailable(p, slug as DocProduct)
-          ? portPageUrl(p, defaults[p.slug] ?? 'latest', productApiPath(slug as DocProduct)) : null,
+          ? portPageUrl(p, versionFor(p.slug), productApiPath(slug as DocProduct)) : null,
         ...(slug === 'mcp' ? { protocol: productAvailable(p, 'mcp')
-          ? portPageUrl(p, defaults[p.slug] ?? 'latest', 'mcp/tools').replace(/\/$/, '.json') : null } : {}),
+          ? portPageUrl(p, versionFor(p.slug), 'mcp/tools').replace(/\/$/, '.json') : null } : {}),
         source: API_MODELS[p.slug]?.sources?.find((source) => source.product === slug),
       })),
       extracted: API_MODELS[p.slug]
         ? {
             symbols: API_MODELS[p.slug].symbols.length,
             extractor: API_MODELS[p.slug].extractor,
-            inventory: `${refBase}${p.slug}/${defaults[p.slug] ?? 'latest'}/reference/objects.inv`,
+            inventory: `${refBase}${p.slug}/${versionFor(p.slug)}/reference/objects.inv`,
           }
         : null,
       documentation: documentationAreas(p.slug).map((area) => ({
@@ -141,7 +145,7 @@ export const GET: APIRoute = async ({ site }) => {
         name: area.label,
         kind: area.kind,
         availability: area.kind === 'unavailable' ? 'unpublished' : 'available',
-        url: portPageUrl(p, defaults[p.slug] ?? 'latest', area.route),
+        url: portPageUrl(p, versionFor(p.slug), area.route),
         ...(area.kind === 'companion-package' ? {
           package: p.packages?.find((entry) => entry.id === area.package)?.name,
         } : {}),
diff --git a/site/src/pages/index.astro b/site/src/pages/index.astro
index a1552a1c..393d81d8 100644
--- a/site/src/pages/index.astro
+++ b/site/src/pages/index.astro
@@ -13,7 +13,6 @@ import McpInstall from '../components/widgets/McpInstall.astro'
 import AgentPrompt from '../components/widgets/AgentPrompt.astro'
 import { QUICKSTARTS } from '../lib/quickstarts'
 import { withPortRoot, withRoot } from '../lib/site-root'
-import PageToolbar from '../components/PageToolbar.astro'
 import { localesFor } from '../i18n/resolve'
 import { getCollection, render } from 'astro:content'
 import { DEFAULT_LOCALE } from '../i18n/locales'
@@ -254,12 +253,10 @@ const noindexLanding = locale !== DEFAULT_LOCALE && !LandingContent
 >
   {LandingContent ? (
     <main class="mx-auto max-w-3xl px-4 py-12 sm:py-16">
-      <PageToolbar breadcrumbs={[{ name: 'libtmux', url: withRoot('/') }]} />
       <LandingContent />
     </main>
   ) : (
   <main class="mx-auto max-w-7xl px-4 py-12 sm:py-16">
-    <PageToolbar breadcrumbs={[{ name: 'libtmux', url: withRoot('/') }]} />
     <!-- Hero -->
     <section class="max-w-3xl">
       <h1 class="text-4xl font-semibold tracking-tight sm:text-5xl">libtmux</h1>
diff --git a/site/src/pages/search.astro b/site/src/pages/search.astro
index 42e853ff..a170bf63 100644
--- a/site/src/pages/search.astro
+++ b/site/src/pages/search.astro
@@ -3,9 +3,15 @@ import { ALL_TRANSLATED } from '../i18n/resolve'
 import BaseLayout from '../layouts/BaseLayout.astro'
 import SearchPanel from '../components/SearchPanel.astro'
 import PageToolbar from '../components/PageToolbar.astro'
-import { withRoot } from '../lib/site-root'
+import { withPortRoot, withRoot } from '../lib/site-root'
+import { PORT_BY_SLUG } from '../lib/ports'
+import { buildTarget } from '../lib/versions'
 
-const breadcrumbs = [{ name: 'libtmux', url: withRoot('/') }, { name: 'Search', url: withRoot('/search/') }]
+const port = PORT_BY_SLUG[process.env.LIBTMUX_DOCS_PORT ?? '']
+
+const version = buildTarget(process.env).version
+const searchHref = port ? withPortRoot(`/${port.slug}/${version}/search/`) : withRoot('/search/')
+const breadcrumbs = [{ name: 'libtmux', url: withRoot('/') }, { name: 'Search', url: searchHref }]
 
 /**
  * The search page: the same panel the Cmd-K modal uses.
@@ -31,7 +37,7 @@ const breadcrumbs = [{ name: 'libtmux', url: withRoot('/') }, { name: 'Search',
     <PageToolbar breadcrumbs={breadcrumbs} />
     <h1 class="text-3xl font-semibold tracking-tight">Search</h1>
     <div class="mt-8">
-      <SearchPanel />
+      <SearchPanel initialPort={port?.name} />
     </div>
   </main>
 </BaseLayout>
diff --git a/site/src/plugins/rehype-api-links.ts b/site/src/plugins/rehype-api-links.ts
index 9bcded1f..d0e1d4c2 100644
--- a/site/src/plugins/rehype-api-links.ts
+++ b/site/src/plugins/rehype-api-links.ts
@@ -198,7 +198,7 @@ export function rehypeApiLinks() {
         if (child.tagName === 'code' && !inLink) {
           const text = textOf(child).trim()
           const ctx = {
-            pagePort: rowPort ?? fence.lang ?? sections.at(-1)?.port ?? buildPort,
+            pagePort: String(child.properties?.dataDocPort ?? buildPort ?? rowPort ?? fence.lang ?? sections.at(-1)?.port ?? '') || undefined,
             product,
             before: scope.text,
             symbolHref: (port: string, symbol: ApiSymbol) => productApiHref(API_MODELS[port], symbol, versionOf(port)),
diff --git a/site/src/plugins/rehype-site-root.mjs b/site/src/plugins/rehype-site-root.mjs
index ae67fd53..ec9782b4 100644
--- a/site/src/plugins/rehype-site-root.mjs
+++ b/site/src/plugins/rehype-site-root.mjs
@@ -1,4 +1,6 @@
 import { visit } from 'unist-util-visit'
+import { proseHref } from '../lib/docs-paths.ts'
+import { buildTarget } from '../lib/versions.ts'
 
 /**
  * Rewrite root-relative links against the deploy root.
@@ -15,16 +17,19 @@ import { visit } from 'unist-util-visit'
  */
 export function rehypeSiteRoot() {
   const root = (process.env.LIBTMUX_DOCS_ROOT || '/').replace(/\/+$/, '')
-  if (!root) return () => {}
+  const buildPort = process.env.LIBTMUX_DOCS_PORT
+  const defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
 
-  return (tree) => {
+  return (tree, file) => {
+    const port = file?.data?.astro?.frontmatter?.port || buildPort
+    const version = port === buildPort ? buildTarget(process.env).version : (defaults[port] || 'latest')
     visit(tree, 'element', (node) => {
       const attr = node.tagName === 'a' ? 'href' : node.tagName === 'img' ? 'src' : null
       if (!attr) return
       const value = node.properties?.[attr]
       // Only single-leading-slash paths: '//host' is protocol-relative.
       if (typeof value !== 'string' || !value.startsWith('/') || value.startsWith('//')) return
-      node.properties[attr] = `${root}${value}`
+      node.properties[attr] = attr === 'href' ? proseHref(value, root, port, version) : `${root}${value}`
     })
   }
 }
diff --git a/site/src/plugins/remark-port-code.mjs b/site/src/plugins/remark-port-code.mjs
index 3b54b0cf..fab4fde0 100644
--- a/site/src/plugins/remark-port-code.mjs
+++ b/site/src/plugins/remark-port-code.mjs
@@ -1,32 +1,10 @@
-import { existsSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-/**
- * The committed copy of every source a fence inlines, written by
- * `scripts/gen-example-sources.mjs`.
- *
- * A static import, like `site/src/data/mcp-tools.json` elsewhere, and not a
- * path read at runtime: this module is bundled, so `import.meta.url` inside
- * the build points at `.astro/.prerender/chunks/`, and a path relative to it
- * resolves to nothing. That failure is quiet in the worst way — the cache
- * simply looks empty, and the build reports the source as missing rather than
- * as unreadable.
- */
+import { resolvePortBody, resolvePortContent } from '../lib/workspace-shared-slots.ts'
+/** Static import keeps source bytes available in bundled HTML and Markdown exports. */
 import CACHE from '../data/example-sources.json' with { type: 'json' }
 import { visit } from 'unist-util-visit'
 
-/**
- * One prose source, per-language code.
- *
- * Playwright serves the same guide at /docs/intro and /python/docs/intro with
- * the code samples swapped. This does the same thing without duplicating the
- * prose: a page carries a fenced block per language, and a build for one port
- * drops the fences belonging to the others.
- *
- * The root build keeps every fence, which is what makes the cross-language
- * view work and what keeps a page readable while it is being written.
- */
-
 /**
  * Fence language to port slug. A language absent here — console, json, yaml,
  * toml, diff — belongs to no port and always survives, because it is setup or
@@ -62,26 +40,7 @@ export const LANG_TO_PORT = {
   swift: 'swift',
 }
 
-/**
- * Checkout root per port, mirroring ports.ts. Used to resolve `file=`.
- * @type {Record<string, string | undefined>}
- */
-/**
- * Where a `file=` fence reads its example from.
- *
- * The `-docs` worktree, not the main checkout, and for the same reason the
- * reference generators use it: every port repository is public, so a change
- * an example needs — a `region:` marker delimiting the lines a page quotes —
- * cannot be committed to `master`. The worktrees sit on `docs-site`, which
- * pushes to the private fork, so a marker has somewhere to live.
- *
- * Reading the main checkout meant a marker added on `docs-site` was invisible
- * here while being visible to the reference build, which is a confusing half
- * state: the same file, two versions, depending on which part of the assembly
- * asked.
- *
- * Python has no worktree — its docs are built from the checkout directly.
- */
+/** Checkout locations used to refresh the revision-bound cache. */
 export const CHECKOUTS = {
   py: '~/work/python/libtmux',
   ruby: '~/work/libtmux/libtmux-ruby-docs',
@@ -101,21 +60,7 @@ export const CHECKOUTS = {
 
 export const expand = (p) => (p.startsWith('~/') ? join(homedir(), p.slice(2)) : p)
 
-/**
- * Where a port's sources actually are, for this run.
- *
- * `CHECKOUTS` names the paths on the machine this site is normally assembled
- * on. A CI runner has none of them: it checks a port out wherever the runner
- * puts it, so a build there resolved `~/work/libtmux/libtmux-rs-docs`, found
- * nothing, and failed every `file=` fence in that port's pages.
- *
- * `LIBTMUX_DOCS_CHECKOUT_<SLUG>` overrides one port, uppercased —
- * `LIBTMUX_DOCS_CHECKOUT_RS=/home/runner/work/libtmux-rs/libtmux-rs`. Per
- * port rather than one root, because a runner building one port has exactly
- * that port checked out and should not be able to satisfy another port's
- * fences by accident: an unset override is an error at read time, which is
- * the behaviour that catches a half-configured job.
- */
+/** A source-bound CI build supplies its selected checkout through an override. */
 export function checkoutFor(owner) {
   const override = process.env[`LIBTMUX_DOCS_CHECKOUT_${owner.toUpperCase()}`]
   return expand(override || CHECKOUTS[owner] || '')
@@ -134,6 +79,34 @@ export function parseMeta(meta) {
   return out
 }
 
+/** The Markdown twin uses the same prose ownership and source reader as HTML. */
+export function resolvePortCode(body, port, authoredPort, link = (href) => href) {
+  const out = []
+  let fence
+  for (const line of resolvePortBody(body, authoredPort || port).split('\n')) {
+    const marker = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line)
+    if (!fence && marker && !(marker[1][0] === '`' && marker[2].includes('`'))) {
+      const [, language = '', metadata = ''] = /^(\S*)(.*)$/.exec(marker[2].trimStart())
+      const owner = LANG_TO_PORT[language.toLowerCase()]
+      const dropping = Boolean(port && owner && owner !== port && authoredPort !== port)
+      const meta = parseMeta(metadata)
+      fence = { marker: marker[1][0], length: marker[1].length, dropping, replaced: Boolean(meta.file && owner) }
+      if (dropping) continue
+      out.push(line)
+      if (fence.replaced) out.push(readFence(owner, meta, 'Markdown export'))
+    } else if (fence && marker && marker[1][0] === fence.marker
+      && marker[1].length >= fence.length && !marker[2].trim()) {
+      if (!fence.dropping) out.push(line)
+      fence = undefined
+    } else if (!fence?.dropping && !fence?.replaced) {
+      out.push(fence ? line : line
+        .replace(/(`+).*?\1|(\]\()([^\s)]+)(?=[\s)])/g, (all, code, prefix, href) => code ? all : `${prefix}${link(href)}`)
+        .replace(/^( {0,3}\[[^\]]+\]:\s*)(\S+)/, (_all, prefix, href) => `${prefix}${link(href)}`))
+    }
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n')
+}
+
 /**
  * Slice a file between `# region: name` / `# endregion` style markers, so a
  * page can quote one function out of a longer tested example. The comment
@@ -149,18 +122,36 @@ function sliceRegion(source, region) {
 
 export function remarkPortCode() {
   const port = process.env.LIBTMUX_DOCS_PORT || ''
+  const processor = this
 
   return (tree, file) => {
     const removals = []
     // A language-owned guide may also show its parent's API or build files.
     // Filter alternate examples only in the shared, cross-language prose.
     const authoredPort = file?.data?.astro?.frontmatter?.port
+    const raw = String(file?.value ?? '')
+    const { body: selected, portAt } = resolvePortContent(raw, authoredPort || port || undefined)
+    // Parse the selected source before headings, highlighting or API linking.
+    // The Markdown export uses the same selector, including nested regions.
+    if (raw !== selected) tree.children = processor.parse(selected).children
+
+    visit(tree, 'inlineCode', (node) => {
+      const owner = portAt(node.position?.start.offset ?? -1)
+      if (!owner) return
+      node.data ??= {}
+      node.data.hProperties = { ...node.data.hProperties, dataDocPort: owner }
+    })
 
     visit(tree, 'code', (node, _index, parent) => {
       const lang = (node.lang || '').toLowerCase()
       const owner = LANG_TO_PORT[lang]
       const meta = parseMeta(node.meta)
 
+      if (port && owner && owner !== port && authoredPort !== port) {
+        removals.push([parent, node])
+        return
+      }
+
       // A fence may name a file in that port's checkout instead of carrying a
       // copy of it. Reading it at build time is what stops a snippet drifting
       // from the code its own repository tests.
@@ -168,9 +159,6 @@ export function remarkPortCode() {
         node.value = readFence(owner, meta, file?.path)
       }
 
-      // Untagged fences and shared languages (console, json, ...) stay in
-      // every build. Only a fence that belongs to a *different* port goes.
-      if (port && owner && owner !== port && authoredPort !== port) removals.push([parent, node])
     })
 
     for (const [parent, node] of removals) {
@@ -180,15 +168,6 @@ export function remarkPortCode() {
   }
 }
 
-/**
- * The body of a `file="..."` fence, read from the port's checkout.
- *
- * Exported because the HTML pages are not the only consumer: llms-full.txt has
- * to inline the same content, and reading it from the Markdown *source* there
- * would ship a file full of empty code fences — precisely the source-versus-
- * resolved bug notes/research/10-llms-and-agents.md exists to document. One
- * reader, so the two cannot disagree.
- */
 /**
  * @param {string} owner
  * @param {{ file?: string, region?: string }} meta
@@ -196,24 +175,20 @@ export function remarkPortCode() {
  * @returns {string}
  */
 export function readFence(owner, meta, pagePath) {
-  const abs = join(checkoutFor(owner), meta.file)
-  /*
-   * The checkout wins when it is there, so a local build always shows what
-   * the port currently tests and the cache can never mask a change. The cache
-   * is what makes the build run where the checkouts are not — every CI runner
-   * — and `gen-example-sources.mjs --check` in the suite is what keeps the two
-   * in step. Only both being absent is an error.
-   */
-  let source
-  if (existsSync(abs)) source = readFileSync(abs, 'utf8')
-  else source = CACHE[`${owner}:${meta.file}`]
+  const cached = CACHE[`${owner}:${meta.file}`]
+  // Assembly refreshes the cache with git show at the documented revision.
+  // Reading a nearby working tree here would silently replace those bytes.
+  let source = cached?.content
+  if (process.env.LIBTMUX_DOCS_PORT === owner && process.env.LIBTMUX_DOCS_SOURCE_SHA
+      && cached?.revision !== process.env.LIBTMUX_DOCS_SOURCE_SHA) {
+    throw new Error(`${pagePath ?? 'page'}: ${owner}:${meta.file} does not match the selected source revision`)
+  }
 
   if (source === undefined) {
     // Fail the build rather than ship a silently empty example: a missing
     // tested source is exactly the drift this is meant to catch.
     throw new Error(
       `${pagePath ?? 'page'}: cannot inline ${meta.file} for ${owner} — ` +
-        `absent from ${checkoutFor(owner) || '<no checkout configured>'} and from ` +
         'site/src/data/example-sources.json (run scripts/gen-example-sources.mjs)',
     )
   }
diff --git a/site/src/styles/api-tree.css b/site/src/styles/api-tree.css
index b11ab6c4..34c14f35 100644
--- a/site/src/styles/api-tree.css
+++ b/site/src/styles/api-tree.css
@@ -45,7 +45,6 @@
  * take the tree's height. */
 .api-nav__menu {
   margin-bottom: 0.5rem;
-  padding-bottom: 0.5rem;
   border-bottom: 1px solid var(--color-edge);
 }
 
@@ -53,6 +52,7 @@
   display: flex;
   align-items: center;
   gap: 0.35rem;
+  min-height: 2rem;
   padding: 0.35rem 0.5rem;
   border-radius: 0.25rem;
   color: var(--color-muted);
@@ -60,6 +60,7 @@
   list-style: none;
   font-size: 0.75rem;
   font-weight: 600;
+  line-height: 1.25rem;
 }
 
 .api-nav__menu-summary::-webkit-details-marker {
diff --git a/site/test/complete-examples.test.ts b/site/test/complete-examples.test.ts
new file mode 100644
index 00000000..59867940
--- /dev/null
+++ b/site/test/complete-examples.test.ts
@@ -0,0 +1,97 @@
+import { createMarkdownProcessor } from '@astrojs/markdown-remark'
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { Window } from 'happy-dom'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import receipt from './fixtures/capture-examples.json'
+import products from './fixtures/product-examples.json'
+import { remarkPortCode, resolvePortCode } from '../src/plugins/remark-port-code.mjs'
+import { rehypeCodeTabs } from '../src/plugins/rehype-code-tabs.mjs'
+import { docsEntryAvailable, pagePortLinks } from '../src/lib/page-port-links'
+import { docsRoutePath } from '../src/lib/docs-paths'
+
+const readPage = (page: string) => readFileSync(new URL(`../src/content/docs/${page}.md`, import.meta.url), 'utf8')
+const bodyOf = (page: string) => readPage(page).replace(/^---\n[\s\S]*?\n---\n/, '')
+const fences = (markdown: string) => [...markdown.matchAll(/^```(\S+)([^\n]*)\n([\s\S]*?)^```/gm)]
+  .map((match) => ({ language: match[1], title: /title="([^"]+)"/.exec(match[2])?.[1], code: match[3] }))
+const sha256 = (code: string) => createHash('sha256').update(code).digest('hex')
+const examples = [...receipt.examples, ...products.examples]
+
+afterEach(() => vi.unstubAllEnvs())
+
+describe('verified complete programs', () => {
+  // The receipt records separate native runs. This gate protects their exact
+  // bytes through the renderers; changing a hash alone is not a native test.
+  it.each(examples)('keeps the executed $page program and project files intact', (example) => {
+    const selected = resolvePortCode(bodyOf(example.page), example.port)
+    const blocks = fences(selected)
+    for (const file of example.files) {
+      const matches = blocks.filter((block) => block.title === file.name)
+      expect(matches, `${example.port}/${file.name}`).toHaveLength(1)
+      expect(sha256(matches[0].code), `${example.port}/${file.name}`).toBe(file.sha256)
+    }
+    expect(selected).toContain(example.sourceRevision)
+    expect(selected).not.toMatch(/^```[^\n]*(?:\bregion|\bfile)="|^>>> /m)
+    const commands = [...selected.matchAll(/^```console\n([\s\S]*?)^```/gm)]
+      .map((match) => match[1].replace(/^\$ /gm, '').trim())
+    expect(commands).toEqual(example.shellRecipe)
+    const program = blocks.find((block) => block.title === example.files[0].name)!
+    const comment = ['python', 'sh'].includes(example.language) ? /^\s*#/ : /^\s*(?:\/\/|\/\*|\* )/
+    for (const line of program.code.split('\n').filter((line) => comment.test(line))) {
+      expect(line.length, `${example.port}: ${line}`).toBeLessThanOrEqual(80)
+    }
+  })
+
+  it.each(examples)('preserves $page in its root-mounted and native HTML/Markdown', async (example) => {
+    const body = bodyOf(example.page)
+    for (const port of ['', example.port]) {
+      vi.stubEnv('LIBTMUX_DOCS_PORT', port)
+      const renderer = await createMarkdownProcessor({
+        remarkPlugins: [remarkPortCode], rehypePlugins: [rehypeCodeTabs], syntaxHighlight: false,
+      })
+      const html = (await renderer.render(body)).code
+      const window = new Window()
+      try {
+        window.document.body.innerHTML = html
+        const markdown = fences(resolvePortCode(body, port))
+        for (const file of example.files) {
+          const expected = fences(body).find((block) => block.title === file.name)!
+          const rendered = [...window.document.querySelectorAll(`pre > code.language-${expected.language}`)]
+            .map((code) => code.textContent)
+          expect(rendered, `${example.port}/${file.name} HTML`).toContain(expected.code)
+          expect(markdown.find((block) => block.title === file.name)?.code,
+            `${example.port}/${file.name} Markdown`).toBe(expected.code)
+        }
+        expect(window.document.querySelectorAll('libtmux-code-tabs')).toHaveLength(0)
+      } finally {
+        await window.happyDOM.close()
+      }
+    }
+  })
+
+  it('keeps the root about tmux and routes each complete program to its port', async () => {
+    const root = readPage(receipt.page)
+    expect(root).toMatch(/^supportedPorts: \[\]$/m)
+    const blocks = fences(bodyOf(receipt.page))
+    expect(blocks.length).toBeGreaterThan(0)
+    expect(blocks.every((block) => ['bash', 'sh', 'shell', 'console'].includes(block.language))).toBe(true)
+    expect(sha256(blocks.find((block) => block.title === receipt.rootExample.file)!.code))
+      .toBe(receipt.rootExample.sha256)
+    expect(root).toContain(receipt.rootExample.shellRecipe)
+    expect(root).not.toMatch(/import libtmux|use libtmux|using LibTmux|#include|package main/)
+    const docs = [{ id: receipt.page, data: { supportedPorts: [] as string[] } }, ...receipt.examples.map((example) => {
+      expect(readPage(example.page)).toContain(`port: ${example.port}\n`)
+      expect(readPage(example.page)).toContain(`route: ${receipt.page}\n`)
+      expect(root).toContain(`/${example.port}/latest/${receipt.page}/`)
+      return { id: example.page, data: { port: example.port, route: receipt.page } }
+    })]
+    expect(new Set(docs.map((doc) => docsRoutePath(doc))).size).toBe(9)
+    for (const example of receipt.examples) {
+      const available = docs.filter((doc) => docsEntryAvailable(doc, example.port))
+      expect(available.map((doc) => docsRoutePath(doc, example.port))).toEqual([receipt.page])
+    }
+    const links = pagePortLinks({ pagePath: receipt.page, version: 'latest', defaults: {}, docs })
+    expect(links.filter((link) => link.links.length).map((link) => link.port).sort())
+      .toEqual(receipt.examples.map((example) => example.port).sort())
+  })
+})
diff --git a/site/test/example-sources.test.ts b/site/test/example-sources.test.ts
index 14fe82ea..7e8cd35e 100644
--- a/site/test/example-sources.test.ts
+++ b/site/test/example-sources.test.ts
@@ -6,18 +6,18 @@ import { describe, expect, it } from 'vitest'
 import { CHECKOUTS, LANG_TO_PORT, checkoutFor } from '../src/plugins/remark-port-code.mjs'
 
 /**
- * Where the documented examples come from, and how many are checked by anyone.
+ * Where the documented example bytes come from.
  *
  * A fence written `\`\`\`python file="examples/quickstart.py"` is read out of
- * that port's own checkout at build time, so the port's test suite is what
- * keeps it honest — the docs cannot drift from code the port itself runs. A
- * fence with the code typed inline has nothing behind it: it renders
- * perfectly while calling a method that was renamed two releases ago.
+ * that port's revision-bound source cache. This prevents transcription drift,
+ * but does not prove the displayed region is a complete, executable program.
+ * Inline programs can also have separate native proof, as the capture page
+ * does. Its receipt and rendering gate live in complete-examples.test.ts.
  *
  * So two things are asserted. Every `file=` reference must resolve, because a
  * renamed example upstream degrades quietly rather than failing. And the count
  * of sourced examples must not fall, because the way this erodes is one
- * convenient inline snippet at a time.
+ * unreviewed inline snippet at a time.
  */
 const CONTENT = join(dirname(fileURLToPath(import.meta.url)), '../src/content/docs')
 
@@ -25,8 +25,7 @@ const CONTENT = join(dirname(fileURLToPath(import.meta.url)), '../src/content/do
  * How many fences are sourced from a port checkout today.
  *
  * Raise this as examples are converted; it exists to stop the number going
- * the other way. It is not a target — 14 of 236 is poor, and the remaining
- * 222 are unverified by anything.
+ * the other way. It measures source inclusion, not execution coverage.
  */
 const SOURCED_FLOOR = 14
 
@@ -87,22 +86,14 @@ describe('documented examples', () => {
     },
   )
 
-  it('does not lose ground on examples sourced from tested code', () => {
+  it('retains the expected coverage of revision-bound source inclusions', () => {
     const share = `${sourced.length}/${all.length}`
     expect(sourced.length, `examples sourced from a port checkout (${share})`).toBeGreaterThanOrEqual(
       SOURCED_FLOOR,
     )
   })
 
-  it('reports how much of the corpus nothing verifies, per port', () => {
-    // Not a failure — a number, kept visible and attributable. An inline
-    // example can be wrong without anything noticing, and one total hides
-    // which port is worst placed to fix it.
-    //
-    // A sourced fence names a file in that port's repository, so the port's
-    // own test suite executes it. An inline one is executed by nobody: it is
-    // a fragment, not a program, and converting it means finding or writing
-    // the example it should have pointed at.
+  it('reports source inclusion by port without claiming native execution', () => {
     const byPort = new Map<string, { sourced: number; inline: number }>()
     for (const f of all) {
       const port = LANG_TO_PORT[f.lang] ?? f.lang
@@ -117,7 +108,7 @@ describe('documented examples', () => {
       .map(([port, r]) => `  ${port.padEnd(7)} ${String(r.sourced).padStart(3)} sourced, ${String(r.inline).padStart(3)} inline`)
 
     console.info(
-      `example coverage: ${sourced.length} of ${all.length} sourced from code a port executes\n` +
+      `example sources: ${sourced.length} of ${all.length} included from port source (execution coverage not inferred)\n` +
         lines.join('\n'),
     )
     expect(byPort.size, 'every port appears in the breakdown').toBeGreaterThan(0)
diff --git a/site/test/fixtures/capture-examples.json b/site/test/fixtures/capture-examples.json
new file mode 100644
index 00000000..1a95594c
--- /dev/null
+++ b/site/test/fixtures/capture-examples.json
@@ -0,0 +1,224 @@
+{
+  "page": "examples/capture-pane-output",
+  "scope": "Exact complete program execution; routine site tests verify these bytes and their rendering, not native execution.",
+  "examples": [
+    {
+      "port": "py",
+      "language": "python",
+      "sourceRevision": "9fdd083a8181a827889337b63cd4e6daea661a8c",
+      "sourceRepository": "tmux-python/libtmux",
+      "files": [
+        {
+          "name": "capture.py",
+          "sha256": "51bd1cb56342cf8a390f4c70101c5f04357ce0ac9a808d74abe2e5dd1215996a"
+        }
+      ],
+      "toolchain": [
+        "Python 3.14.6"
+      ],
+      "tmux": [
+        "3.7c"
+      ],
+      "page": "ports/py/examples/capture-pane-output",
+      "shellRecipe": [
+        "uv run \\\n    --with 'libtmux @ git+https://github.com/tmux-python/libtmux@9fdd083a8181a827889337b63cd4e6daea661a8c' \\\n    capture.py"
+      ]
+    },
+    {
+      "port": "ts",
+      "language": "typescript",
+      "sourceRevision": "3fe1ca654b81b8cbf4a13b777a001a3298c87a6f",
+      "sourceRepository": "libtmux/libtmux-ts",
+      "files": [
+        {
+          "name": "capture.ts",
+          "sha256": "b005ade16cfe7183cf1b17982546ceb4a79ffc74996422c262a0a6c0497450bb"
+        },
+        {
+          "name": "package.json",
+          "sha256": "acb06879bf3e3e5ce85125d64a72ff5b2579e87a66085961b1f7b88eaa813020"
+        }
+      ],
+      "toolchain": [
+        "Bun 1.4.2"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/ts/examples/capture-pane-output",
+      "shellRecipe": [
+        "git clone https://github.com/libtmux/libtmux-ts libtmux &&\n  git -C libtmux checkout 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f &&\n  bun install &&\n  bun run capture.ts"
+      ]
+    },
+    {
+      "port": "go",
+      "language": "go",
+      "sourceRevision": "bb06e26e116e941813ca40bf45e7e3a47d38f52a",
+      "sourceRepository": "libtmux/libtmux-go",
+      "files": [
+        {
+          "name": "main.go",
+          "sha256": "fff130e7c12cd990d4e8af309a6a1e269b0ae2bf9cabfc2fbb422a90ccf2e033"
+        },
+        {
+          "name": "go.mod",
+          "sha256": "4d6b8b0545fb56b9a65bbd9276569c775e115ff61b5ccbcc8fe6281d7d521f8a"
+        }
+      ],
+      "toolchain": [
+        "Go 1.26.8"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/go/examples/capture-pane-output",
+      "shellRecipe": [
+        "git clone https://github.com/libtmux/libtmux-go libtmux &&\n  git -C libtmux checkout bb06e26e116e941813ca40bf45e7e3a47d38f52a &&\n  GOWORK=off go mod tidy &&\n  GOWORK=off go run ."
+      ]
+    },
+    {
+      "port": "rs",
+      "language": "rust",
+      "sourceRevision": "d4e08b4eaab62ef4eeedab79b47973ae9a1de310",
+      "sourceRepository": "libtmux/libtmux-rs",
+      "files": [
+        {
+          "name": "main.rs",
+          "sha256": "a207a4ace3c97f9226503ccc90b03e81cbd1704333ffa6d44d4d6544deef7b67"
+        },
+        {
+          "name": "Cargo.toml",
+          "sha256": "1051eb82a28d7f94b3a57e77102c805db67c384e9e5f1f1f56be901f7b821443"
+        }
+      ],
+      "toolchain": [
+        "Rust 1.97.1"
+      ],
+      "tmux": [
+        "3.7c"
+      ],
+      "page": "ports/rs/examples/capture-pane-output",
+      "shellRecipe": [
+        "git clone https://github.com/libtmux/libtmux-rs libtmux &&\n  git -C libtmux checkout d4e08b4eaab62ef4eeedab79b47973ae9a1de310 &&\n  cargo +1.97.1 run"
+      ]
+    },
+    {
+      "port": "java",
+      "language": "java",
+      "sourceRevision": "842228310449e879ebcaa3f910597757c9dbffd6",
+      "sourceRepository": "libtmux/libtmux-java",
+      "files": [
+        {
+          "name": "Capture.java",
+          "sha256": "91433bad174fb4db9330e36307db8face5739963bae754d94862cbbdbbec6c63"
+        }
+      ],
+      "toolchain": [
+        "JDK 25.0.3",
+        "library bytecode target Java 21"
+      ],
+      "tmux": [
+        "3.7c"
+      ],
+      "page": "ports/java/examples/capture-pane-output",
+      "shellRecipe": [
+        "git clone https://github.com/libtmux/libtmux-java libtmux &&\n  git -C libtmux checkout 842228310449e879ebcaa3f910597757c9dbffd6 &&\n  (cd libtmux && ./gradlew :libtmux:jar) &&\n  java --class-path 'libtmux/libtmux/build/libs/*' Capture.java"
+      ]
+    },
+    {
+      "port": "dotnet",
+      "language": "csharp",
+      "sourceRevision": "320dc64f4b8b7815842471327a5e6b84a1499bf8",
+      "sourceRepository": "libtmux/libtmux-dotnet",
+      "files": [
+        {
+          "name": "Program.cs",
+          "sha256": "4fd0396a237012636ed7c8d74760a4ddd2614104c78d2dc211a5b1882cb6fc40"
+        },
+        {
+          "name": "Capture.csproj",
+          "sha256": "badc813042195a1ac170ad3952437994fe7a85425b09b888f3e1e20f6fa71d15"
+        }
+      ],
+      "toolchain": [
+        ".NET SDK 10.0.302"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/dotnet/examples/capture-pane-output",
+      "shellRecipe": [
+        "git clone https://github.com/libtmux/libtmux-dotnet libtmux-source &&\n  git -C libtmux-source checkout 320dc64f4b8b7815842471327a5e6b84a1499bf8 &&\n  dotnet build Capture.csproj --maxcpucount:1 &&\n  dotnet run --project Capture.csproj --no-build"
+      ]
+    },
+    {
+      "port": "cxx",
+      "language": "cpp",
+      "sourceRevision": "393d4b0ad666f18a6581f1eb281741a75a7503f0",
+      "sourceRepository": "libtmux/libtmux-cxx",
+      "files": [
+        {
+          "name": "capture.cpp",
+          "sha256": "023554185b1599bf626c7ff5f8eceafae48d68391bd2550d64c2673ad0d55f52"
+        },
+        {
+          "name": "CMakeLists.txt",
+          "sha256": "cf54e677b22402b0b07e62e36288d32d98ca496583fbf1cc69dc5f39f570d2b4"
+        }
+      ],
+      "toolchain": [
+        "Clang 18",
+        "libc++ 18",
+        "CMake 3.25+"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/cxx/examples/capture-pane-output",
+      "shellRecipe": [
+        "git clone https://github.com/libtmux/libtmux-cxx libtmux-source &&\n  git -C libtmux-source checkout 393d4b0ad666f18a6581f1eb281741a75a7503f0 &&\n  cmake -S . -B build -G Ninja \\\n    -DCMAKE_CXX_COMPILER=clang++ \\\n    -DCMAKE_CXX_FLAGS=-stdlib=libc++ \\\n    -DCMAKE_EXE_LINKER_FLAGS=-stdlib=libc++ &&\n  cmake --build build --target capture --parallel 2 &&\n  ./build/capture"
+      ]
+    },
+    {
+      "port": "swift",
+      "language": "swift",
+      "sourceRevision": "254f8b2be7eb60cacc3ffcb3ea8e456784f582df",
+      "sourceRepository": "libtmux/libtmux-swift",
+      "files": [
+        {
+          "name": "Capture.swift",
+          "sha256": "4f4258a1eb646d70712559f5a4d975d1cc36fd1805a77cbb8ddc63bc812db6da"
+        },
+        {
+          "name": "Package.swift",
+          "sha256": "8ec79477f33f8e587ab240e2026a09023e71b2c7f3724bed2b98de1a84b87645"
+        }
+      ],
+      "toolchain": [
+        "Swift 6.2.4"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/swift/examples/capture-pane-output",
+      "shellRecipe": [
+        "git clone https://github.com/libtmux/libtmux-swift libtmux-source &&\n  git -C libtmux-source checkout 254f8b2be7eb60cacc3ffcb3ea8e456784f582df &&\n  swift run --jobs 2 Capture"
+      ]
+    }
+  ],
+  "rootExample": {
+    "file": "capture.sh",
+    "sha256": "1127dac3da7132067f2a93bc50f0e81424007e363a756f566ccb7628005406b7",
+    "tmux": [
+      "3.2a",
+      "3.7c"
+    ],
+    "shellRecipe": "sh capture.sh",
+    "source": "https://github.com/tmux/tmux/blob/94796f6b1182507efac8a272fc309a79e22e58a5/tmux.1"
+  }
+}
diff --git a/site/test/fixtures/product-examples.json b/site/test/fixtures/product-examples.json
new file mode 100644
index 00000000..1b04649e
--- /dev/null
+++ b/site/test/fixtures/product-examples.json
@@ -0,0 +1,148 @@
+{
+  "scope": "Exact complete programs and project files verified by separate native runs; routine tests protect bytes and rendering, not native execution.",
+  "examples": [
+    {
+      "port": "ts",
+      "language": "typescript",
+      "sourceRevision": "3fe1ca654b81b8cbf4a13b777a001a3298c87a6f",
+      "sourceRepository": "libtmux/libtmux-ts",
+      "files": [
+        {
+          "name": "workspace.ts",
+          "sha256": "20905548b12c76a93a0c6c0e6f939ade736bcc1b753dbd767125a71bf26b87ca"
+        },
+        {
+          "name": "package.json",
+          "sha256": "cb9213ba62a6270ff81c9cf124ccc9c0bfe82d8b72712393e8c09b0baf75c374"
+        }
+      ],
+      "toolchain": [
+        "Bun 1.4.2"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/ts/workspace/internals/examples",
+      "shellRecipe": [
+        "mkdir workspace-example && cd workspace-example",
+        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-ts.git && \\\n    git -C libtmux-source fetch --depth 1 origin 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
+        "bun install --production",
+        "bun run workspace.ts"
+      ]
+    },
+    {
+      "port": "ts",
+      "language": "typescript",
+      "sourceRevision": "3fe1ca654b81b8cbf4a13b777a001a3298c87a6f",
+      "sourceRepository": "libtmux/libtmux-ts",
+      "files": [
+        {
+          "name": "mcp.ts",
+          "sha256": "982f01a2d52160b6fbc0ed982c98542c4c8341022c1dac9da10809083a1124f7"
+        },
+        {
+          "name": "package.json",
+          "sha256": "0ae56500bcb2a1e16d6406476e09577d5ee284740bb4cb7eb04d53af2952e854"
+        }
+      ],
+      "toolchain": [
+        "Bun 1.4.2"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/ts/mcp/examples",
+      "shellRecipe": [
+        "mkdir mcp-example && cd mcp-example",
+        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-ts.git && \\\n    git -C libtmux-source fetch --depth 1 origin 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
+        "bun install --production",
+        "bun run mcp.ts"
+      ]
+    },
+    {
+      "port": "swift",
+      "language": "swift",
+      "sourceRevision": "254f8b2be7eb60cacc3ffcb3ea8e456784f582df",
+      "sourceRepository": "libtmux/libtmux-swift",
+      "files": [
+        {
+          "name": "Sources/WorkspaceExample/WorkspaceExample.swift",
+          "sha256": "17787f2ccf5e5d1bca44e113c2608810b8787caa6da9ecd65f371b5ba57c72b1"
+        },
+        {
+          "name": "Package.swift",
+          "sha256": "67cc9cbf83ebb2ffb9aaf083bda44e048456d94d718ab03c0cf15755052cb3cf"
+        }
+      ],
+      "toolchain": [
+        "Swift 6.2.4"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/swift/workspace/internals/examples",
+      "shellRecipe": [
+        "mkdir swift-workspace-example && cd swift-workspace-example && \\\n  mkdir -p Sources/WorkspaceExample",
+        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD",
+        "swift run --jobs 2 WorkspaceExample"
+      ]
+    },
+    {
+      "port": "swift",
+      "language": "swift",
+      "sourceRevision": "254f8b2be7eb60cacc3ffcb3ea8e456784f582df",
+      "sourceRepository": "libtmux/libtmux-swift",
+      "files": [
+        {
+          "name": "Sources/MCPExample/MCPExample.swift",
+          "sha256": "8bce43add22fad463aae112fde6e8ebb00061db00b829d61cad16c72d7a35306"
+        },
+        {
+          "name": "Package.swift",
+          "sha256": "c4042573a8834c5aca699bd1e950be9f0f625fb4f63bed089f20b7d2c7a109b4"
+        }
+      ],
+      "toolchain": [
+        "Swift 6.2.4"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/swift/mcp/examples",
+      "shellRecipe": [
+        "mkdir swift-mcp-example && cd swift-mcp-example && \\\n  mkdir -p Sources/MCPExample",
+        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD",
+        "swift run --jobs 2 MCPExample"
+      ]
+    },
+    {
+      "port": "swift",
+      "language": "sh",
+      "sourceRevision": "254f8b2be7eb60cacc3ffcb3ea8e456784f582df",
+      "sourceRepository": "libtmux/libtmux-swift",
+      "files": [
+        {
+          "name": "run-mcp.sh",
+          "sha256": "6a26dc211be10156871e51638b2fe855d3d2a958145824b0f14ce790825ecbe0"
+        }
+      ],
+      "toolchain": [
+        "Swift 6.2.4"
+      ],
+      "tmux": [
+        "3.2a",
+        "3.7c"
+      ],
+      "page": "ports/swift/mcp/guides",
+      "shellRecipe": [
+        "mkdir swift-mcp-client && cd swift-mcp-client",
+        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD && \\\n  swift build --package-path libtmux-source --product libtmux-mcp --jobs 2",
+        "sh run-mcp.sh"
+      ]
+    }
+  ]
+}
diff --git a/site/test/machine-readable.test.ts b/site/test/machine-readable.test.ts
index 120f0e50..050db913 100644
--- a/site/test/machine-readable.test.ts
+++ b/site/test/machine-readable.test.ts
@@ -40,6 +40,50 @@ const value = (tag: string, name: string) => {
   return match ? (match[1] ?? match[2] ?? match[3]) : undefined
 }
 
+/** Directory links must belong to the page's library, not just a known repository. */
+function githubSourceMatches(href: string | undefined, page: string): boolean {
+  if (!href) return false
+  const path = page.replace(/^pr-[1-9][0-9]*\//, '')
+  const port = PORTS.find((entry) => entry.slug === path.split('/')[1])
+  if (port?.source) {
+    const tree = /^https:\/\/github\.com\/([^/]+\/[^/]+)\/tree\/([^/?#]+)\/(.+?)\/?$/.exec(href)
+    return tree?.[1] === port.repo && tree[3] === port.source.path
+  }
+  const repo = /^https:\/\/github\.com\/([^/]+\/[^/]+?)\/?$/.exec(href)?.[1]
+  return !!repo && REPOS.has(repo)
+}
+
+describe('GitHub footer targets', () => {
+  it.each(['kotlin', 'scala'])('accepts the declared %s directory at a branch, tag or revision', (slug) => {
+    for (const ref of ['master', 'v0.0.1-alpha.17', 'a'.repeat(40), 'feature%2Fsource-links']) {
+      for (const prefix of ['', 'pr-50/']) {
+        expect(githubSourceMatches(`https://github.com/libtmux/libtmux-java/tree/${ref}/libtmux-${slug}`, `${prefix}en/${slug}/latest/index.html`)).toBe(true)
+      }
+    }
+  })
+
+  it('retains repository roots for core libraries, companions and shared docs', () => {
+    expect(githubSourceMatches('https://github.com/libtmux/libtmux-java/', 'en/java/latest/index.html')).toBe(true)
+    expect(githubSourceMatches('https://github.com/tmux-python/libtmux-mcp/', 'en/py/latest/mcp/index.html')).toBe(true)
+    expect(githubSourceMatches('https://github.com/libtmux/docs/', 'en/index.html')).toBe(true)
+  })
+
+  it.each([
+    undefined,
+    'https://github.com/libtmux/libtmux-java/',
+    'https://github.com/libtmux/libtmux-java/tree/master/libtmux-scala',
+    'https://github.com/libtmux/libtmux-java/tree/master/other-directory',
+    'https://github.com/libtmux/libtmux-java/tree/master/libtmux-kotlin/README.md',
+    'https://github.com/libtmux/libtmux-java/tree//libtmux-kotlin',
+    'https://github.com/unrelated/project/tree/master/libtmux-kotlin',
+    'https://example.com/libtmux/libtmux-java/tree/master/libtmux-kotlin',
+  ])('rejects an undeclared Kotlin target: %s', (href) => {
+    for (const prefix of ['', 'pr-50/']) {
+      expect(githubSourceMatches(href, `${prefix}en/kotlin/latest/index.html`)).toBe(false)
+    }
+  })
+})
+
 function htmlFiles(): string[] {
   return LOCALES.filter((locale) => existsSync(join(BUCKET_ROOT, locale))).flatMap((locale) =>
     (readdirSync(join(BUCKET_ROOT, locale), { recursive: true }) as string[])
@@ -140,8 +184,7 @@ describe.skipIf(!SITE_BUILT)('machine-readable footer', () => {
         if (footer.source !== raw[2]) problems.push(`${page}: source ${footer.source} differs from raw path ${raw[2]}`)
         if (raw[1] === 'libtmux/docs' && !tracked.has(raw[2])) problems.push(`${page}: source ${raw[2]} is not tracked`)
       }
-      const repo = footer.github && /^https:\/\/github\.com\/([^/]+\/[^/]+?)\/?$/.exec(footer.github)?.[1]
-      if (!repo || !REPOS.has(repo)) problems.push(`${page}: GitHub icon ${footer.github} is not a libtmux repository`)
+      if (!githubSourceMatches(footer.github, page)) problems.push(`${page}: GitHub icon ${footer.github} is not a declared source target`)
     }
     expect(checked, 'shell pages found').toBeGreaterThan(0)
     expect(problems.slice(0, 40), `${problems.length} footer problems across ${checked} pages`).toEqual([])
diff --git a/site/test/native-switchers.test.ts b/site/test/native-switchers.test.ts
index ba35ad54..0b63535d 100644
--- a/site/test/native-switchers.test.ts
+++ b/site/test/native-switchers.test.ts
@@ -22,10 +22,12 @@ const pageLinks = {
   },
 }
 
-async function load(path: string, body = '') {
+async function load(path: string, body = '', head = '') {
   const window = new Window({ url: `https://libtmux.org${base}/py/latest/${path}` })
   windows.push(window)
   window.document.body.innerHTML = body
+  window.document.head.innerHTML = head
+  const initialHeader = window.document.querySelector('[data-lt-shell="header"]')
   const requests: string[] = []
   window.fetch = (async (url: unknown) => {
     requests.push(String(url))
@@ -34,7 +36,7 @@ async function load(path: string, body = '') {
   window.eval(source)
   window.document.dispatchEvent(new window.Event('DOMContentLoaded'))
   await window.happyDOM.waitUntilComplete()
-  return { window, requests, document: window.document }
+  return { window, requests, document: window.document, initialHeader }
 }
 
 afterEach(async () => {
@@ -42,12 +44,29 @@ afterEach(async () => {
 })
 
 describe('native API page switchers', () => {
+  it('enhances pre-rendered controls without replacing their header or footer', async () => {
+    const rendered = (await load('api/libtmux.session/')).document
+    const body = rendered.body.innerHTML + '<dt class="sig" id="libtmux.Session">Session</dt>'
+    const { window, document, initialHeader } = await load('api/libtmux.session/', body, rendered.head.innerHTML)
+    const header = document.querySelector('[data-lt-shell="header"]')!
+    expect(document.querySelectorAll('[data-lt-shell="header"]')).toHaveLength(1)
+    expect(document.querySelectorAll('[data-lt-shell="footer"]')).toHaveLength(1)
+    expect(document.querySelectorAll('#lt-shell-style')).toHaveLength(1)
+    expect(header).toBe(initialHeader)
+    expect(window.customElements.get('libtmux-version-switcher')).toBeTruthy()
+    expect(header.querySelector('select option')?.getAttribute('value')).toBe('latest')
+    expect(header.querySelector('[data-port-home="ts"]')?.getAttribute('href')).toBe(`${base}/ts/stable/`)
+    expect(header.querySelector('[data-page-port-switcher] a[href$="session-session/"]')).not.toBeNull()
+  })
+
   it('keeps all port homes and manifest requests inside the locale and preview', async () => {
     const { document, requests } = await load('api/libtmux.session/')
     const nav = document.querySelector('nav[aria-label="Language"]')!
     expect(nav.querySelector('[data-port-home="py"]')?.getAttribute('href')).toBe(`${base}/py/latest/`)
     expect(nav.querySelector('[data-port-home="ts"]')?.getAttribute('href')).toBe(`${base}/ts/stable/`)
     expect(nav.querySelector('[data-port-home="rs"]')?.getAttribute('href')).toBe(`${base}/rs/latest/`)
+    expect([...document.querySelectorAll('.lt-shell-search-link')].find((link) => link.textContent === 'Search')?.getAttribute('href'))
+      .toBe(`${base}/py/latest/search/`)
     expect(requests).toEqual([`${base}/versions.json`, `${base}/page-links.json`])
   })
 
diff --git a/site/test/native-theme.test.ts b/site/test/native-theme.test.ts
new file mode 100644
index 00000000..362cb343
--- /dev/null
+++ b/site/test/native-theme.test.ts
@@ -0,0 +1,123 @@
+import { readFileSync } from 'node:fs'
+import { Window } from 'happy-dom'
+import { afterEach, describe, expect, it } from 'vitest'
+
+const nativeScript = readFileSync(new URL('../public/_shell/shell.js', import.meta.url), 'utf8')
+const astroSource = readFileSync(new URL('../src/components/ThemeScript.astro', import.meta.url), 'utf8')
+const astroScript = /<script is:inline>([\s\S]*?)<\/script>/.exec(astroSource)![1]
+const windows: Window[] = []
+const keys = ['color-scheme', 'theme', 'libtmux-theme']
+
+function page(storage: Record<string, string> = {}, system = 'light') {
+  const window = new Window({
+    url: 'https://libtmux.org/en/py/latest/api/libtmux.session/',
+    settings: { device: { prefersColorScheme: system } },
+  })
+  windows.push(window)
+  for (const [key, value] of Object.entries(storage)) window.localStorage.setItem(key, value)
+  const media = window.matchMedia('(prefers-color-scheme: dark)')
+  window.matchMedia = () => media
+  window.fetch = (async () => ({ ok: true, json: async () => ({ schema: 1, ports: {}, defaultVersion: {} }) })) as unknown as typeof window.fetch
+  return { window, media }
+}
+
+function preferences(window: Window) {
+  return Object.fromEntries(keys.flatMap((key) => {
+    const value = window.localStorage.getItem(key)
+    return value === null ? [] : [[key, value]]
+  }))
+}
+
+async function native(window: Window) {
+  window.eval(nativeScript)
+  window.document.dispatchEvent(new window.Event('DOMContentLoaded'))
+  await window.happyDOM.waitUntilComplete()
+}
+
+function astro(window: Window) {
+  window.eval(astroScript)
+}
+
+afterEach(async () => {
+  await Promise.all(windows.splice(0).map((window) => window.happyDOM.abort()))
+})
+
+describe('theme preference across Astro and native pages', () => {
+  it.each([
+    ['dark', 'light', 'dark'], ['light', 'dark', 'light'],
+    ['system', 'dark', 'dark'], ['system', 'light', 'light'],
+  ])('carries Astro %s into a native page with a %s OS preference', async (choice, system, resolved) => {
+    const first = page({ 'color-scheme': choice, theme: 'light', 'libtmux-theme': 'dark' }, system).window
+    astro(first)
+    expect(first.document.documentElement.getAttribute('data-theme-mode')).toBe(resolved)
+
+    const second = page(preferences(first), system).window
+    second.document.body.setAttribute('data-theme', 'light')
+    await native(second)
+    const nativeChoice = choice === 'system' ? 'auto' : choice
+    expect(second.document.body.getAttribute('data-theme')).toBe(nativeChoice)
+    expect(second.document.documentElement.getAttribute('data-theme')).toBe(choice === 'system' ? null : choice)
+    expect(second.document.documentElement.getAttribute('data-theme-mode')).toBe(resolved)
+    expect(second.document.documentElement.style.colorScheme).toBe(resolved)
+    expect(preferences(second)).toEqual({ 'color-scheme': choice, theme: nativeChoice, 'libtmux-theme': nativeChoice })
+  })
+
+  it.each(['light', 'dark', 'auto'])('carries a native %s toggle back into Astro', async (choice) => {
+    const first = page({ 'color-scheme': choice === 'light' ? 'dark' : 'light' }, 'dark').window
+    await native(first)
+    first.document.body.setAttribute('data-theme', choice)
+    first.localStorage.setItem('theme', choice)
+    await first.happyDOM.waitUntilComplete()
+
+    const second = page(preferences(first), 'dark').window
+    astro(second)
+    const siteChoice = choice === 'auto' ? 'system' : choice
+    expect(preferences(first)).toEqual({ 'color-scheme': siteChoice, theme: choice, 'libtmux-theme': choice })
+    expect(second.document.documentElement.getAttribute('data-color-scheme')).toBe(siteChoice)
+    expect(second.document.documentElement.getAttribute('data-theme-mode')).toBe(choice === 'auto' ? 'dark' : choice)
+  })
+
+  it.each([
+    [{ theme: 'dark', 'libtmux-theme': 'light' }, 'dark'],
+    [{ 'libtmux-theme': 'auto' }, 'system'],
+  ] as const)('migrates a legacy native preference: %j', async (stored, choice) => {
+    const { window } = page(stored)
+    await native(window)
+    expect(window.localStorage.getItem('color-scheme')).toBe(choice)
+  })
+
+  it('follows OS changes in auto mode and retains an explicit choice', async () => {
+    const { window, media } = page({ 'color-scheme': 'system' })
+    await native(window)
+    window.happyDOM.settings.device.prefersColorScheme = 'dark'
+    media.dispatchEvent(new window.Event('change'))
+    expect(window.document.documentElement.getAttribute('data-theme-mode')).toBe('dark')
+    expect(window.document.body.getAttribute('data-theme')).toBe('auto')
+
+    window.document.body.setAttribute('data-theme', 'dark')
+    await window.happyDOM.waitUntilComplete()
+    window.happyDOM.settings.device.prefersColorScheme = 'light'
+    media.dispatchEvent(new window.Event('change'))
+    expect(window.document.documentElement.getAttribute('data-theme-mode')).toBe('dark')
+  })
+
+  it('applies an Astro choice from another tab to the native renderer', async () => {
+    const { window } = page({ theme: 'light' })
+    await native(window)
+    window.localStorage.setItem('color-scheme', 'dark')
+    window.dispatchEvent(new window.StorageEvent('storage', { key: 'color-scheme', newValue: 'dark' }))
+    await window.happyDOM.waitUntilComplete()
+    expect(window.document.body.getAttribute('data-theme')).toBe('dark')
+    expect(window.document.documentElement.getAttribute('data-theme-mode')).toBe('dark')
+  })
+
+  it('keeps the native toggle usable when storage is blocked', async () => {
+    const { window } = page()
+    Object.defineProperty(window, 'localStorage', { get() { throw new Error('Storage blocked') } })
+    await native(window)
+    window.document.body.setAttribute('data-theme', 'dark')
+    await window.happyDOM.waitUntilComplete()
+    expect(window.document.documentElement.getAttribute('data-theme-mode')).toBe('dark')
+    expect(window.document.documentElement.getAttribute('data-color-scheme')).toBe('dark')
+  })
+})
diff --git a/site/test/normalize-native-shell.test.ts b/site/test/normalize-native-shell.test.ts
index 5690c52f..e16a5b10 100644
--- a/site/test/normalize-native-shell.test.ts
+++ b/site/test/normalize-native-shell.test.ts
@@ -5,14 +5,61 @@ import { describe, expect, it } from 'vitest'
 import { normalizeNativeShell } from '../../scripts/normalize-native-shell.mjs'
 
 describe('native shell URL normalization', () => {
-  it('normalizes nested HTML/CSS for previews without changing other URLs', () => {
+  it('adds the Sphinx shell to old sources and preserves nested links and redirects', async () => {
+    const directory = mkdtempSync(join(tmpdir(), 'native-sphinx-'))
+    try {
+      mkdirSync(join(directory, 'api/pane'), { recursive: true })
+      const page = join(directory, 'api/pane/index.html')
+      writeFileSync(page, '<html><head><link rel="stylesheet" href="../../_static/theme.css"></head><body><article><a href="#capture">Capture</a><h2 id="capture">Pane</h2></article></body></html>')
+      const redirect = '<html><head><meta http-equiv="refresh" content="0;url=/search/"></head></html>'
+      writeFileSync(join(directory, 'index.html'), redirect)
+      await normalizeNativeShell(directory, '/pr-42/en', { sphinxPort: 'py', version: 'v0.62.0' })
+      const html = readFileSync(page, 'utf8')
+      expect(html).toContain('href="../../_static/libtmux-org.css"')
+      expect(html).toContain('data-pagefind-body data-pagefind-filter="port:Python"')
+      expect(html).toContain('<script defer src="/pr-42/en/_shell/shell.js"></script>')
+      expect(html).toContain('href="../../_static/theme.css"')
+      expect(html).toContain('<a href="#capture">Capture</a>')
+      expect(html.indexOf('id="lt-shell-style"')).toBeLessThan(html.indexOf('</head>'))
+      expect(html.indexOf('data-lt-shell="header"')).toBeLessThan(html.indexOf('<article'))
+      expect(html).toContain('data-current="v0.62.0"')
+      expect(html).toContain('href="/pr-42/en/py/v0.62.0/api/api/pane/"')
+      expect(html.match(/data-lt-shell="header"/g)).toHaveLength(1)
+      expect(html.match(/data-lt-shell="footer"/g)).toHaveLength(1)
+      expect(readFileSync(join(directory, '_static/libtmux-org.css'), 'utf8')).toContain("url('/pr-42/en/_shell/tokens.css')")
+      expect(readFileSync(join(directory, 'index.html'), 'utf8')).toBe(redirect)
+      expect(await normalizeNativeShell(directory, '/pr-42/en/', { sphinxPort: 'py', version: 'v0.62.0' })).toBe(0)
+      expect(readFileSync(page, 'utf8')).toBe(html)
+    } finally {
+      rmSync(directory, { recursive: true, force: true })
+    }
+  })
+
+  it('replaces source-owned integration without duplicate scripts or styles', async () => {
+    const directory = mkdtempSync(join(tmpdir(), 'native-sphinx-'))
+    try {
+      const page = join(directory, 'index.html')
+      writeFileSync(page, '<html><head><link href="_static/libtmux-org.css?v=old" rel="stylesheet"><script src="/_shell/shell.js" defer="defer"></script></head><body><article>Reference</article></body></html>')
+      await normalizeNativeShell(directory, '/en', { sphinxPort: 'py' })
+      const html = readFileSync(page, 'utf8')
+      expect(html.match(/shell\.js/g)).toHaveLength(1)
+      expect(html.match(/libtmux-org\.css/g)).toHaveLength(1)
+      expect(html).not.toContain('?v=old')
+      writeFileSync(page, '<html><body>Truncated source</body></html>')
+      await expect(normalizeNativeShell(directory, '/en', { sphinxPort: 'py' })).rejects.toThrow('no closing head')
+    } finally {
+      rmSync(directory, { recursive: true, force: true })
+    }
+  })
+
+  it('normalizes nested HTML/CSS for previews without changing other URLs', async () => {
     const directory = mkdtempSync(join(tmpdir(), 'native-shell-'))
     try {
       mkdirSync(join(directory, '_static'))
       writeFileSync(join(directory, 'index.html'), '<script src="/_shell/shell.js"></script><a href="/unchanged/">Guide</a>')
       writeFileSync(join(directory, '_static/theme.css'), "@import url('https://libtmux.org/_shell/tokens.css'); .logo{background:url(https://other.example/_shell/logo.svg)}")
-      normalizeNativeShell(directory, '/pr-42/en/')
-      normalizeNativeShell(directory, '/pr-42/en')
+      await normalizeNativeShell(directory, '/pr-42/en/')
+      await normalizeNativeShell(directory, '/pr-42/en')
       expect(readFileSync(join(directory, 'index.html'), 'utf8')).toBe('<script src="/pr-42/en/_shell/shell.js"></script><a href="/unchanged/">Guide</a>')
       expect(readFileSync(join(directory, '_static/theme.css'), 'utf8')).toBe("@import url('/pr-42/en/_shell/tokens.css'); .logo{background:url(https://other.example/_shell/logo.svg)}")
     } finally {
diff --git a/site/test/page-port-links.test.ts b/site/test/page-port-links.test.ts
index 937e79fb..2ac4208b 100644
--- a/site/test/page-port-links.test.ts
+++ b/site/test/page-port-links.test.ts
@@ -2,7 +2,7 @@ import { describe, expect, it, vi } from 'vitest'
 
 vi.stubEnv('LIBTMUX_DOCS_PORT_ROOT', '/pr-42/en')
 vi.stubEnv('LIBTMUX_DOCS_LOCALES_ROOT', '/pr-42')
-const { pagePortLinks } = await import('../src/lib/page-port-links')
+const { docsEntryAvailable, pagePortLinks } = await import('../src/lib/page-port-links')
 const { PORTS, PORT_BY_SLUG } = await import('../src/lib/ports')
 const { localePageHref, localeSourcePath } = await import('../src/i18n/locales')
 
@@ -15,6 +15,17 @@ const docs = [
 const options = { version: 'v1.2.3', defaults: { py: 'stable', ts: 'latest' }, docs }
 
 describe('matching pages in another port', () => {
+  it('uses native equivalents when a shared article does not cover a port', () => {
+    const shared = { id: 'topics/pane-interaction', data: { supportedPorts: ['go', 'py'] } }
+    const native = { id: '_staged/lua/guides/panes', data: { port: 'lua', route: 'guides/panes', aliases: ['topics/pane-interaction'] } }
+    expect(docsEntryAvailable(shared, 'lua')).toBe(false)
+    expect(docsEntryAvailable(shared, 'go')).toBe(true)
+    const links = pagePortLinks({ ...options, docs: [shared, native], pagePath: 'topics/pane-interaction', portSlug: 'go' })
+    expect(links.find((p) => p.port === 'lua')?.links[0].href).toBe('/pr-42/en/lua/latest/guides/panes/')
+    expect(links.find((p) => p.port === 'ruby')?.links).toEqual([])
+    const reverse = pagePortLinks({ ...options, docs: [shared, native], pagePath: 'guides/panes', portSlug: 'lua' })
+    expect(reverse.find((p) => p.port === 'go')?.links[0].href).toBe('/pr-42/en/go/latest/topics/pane-interaction/')
+  })
   it('switches product guides only where the matching page is authored', () => {
     const links = pagePortLinks({ ...options, pagePath: 'workspace/internals/guides', portSlug: 'ts' })
     expect(links.find((p) => p.port === 'ts')?.links[0].href).toBe('/pr-42/en/ts/v1.2.3/workspace/internals/guides/')
diff --git a/site/test/port-prose.test.ts b/site/test/port-prose.test.ts
new file mode 100644
index 00000000..9627130a
--- /dev/null
+++ b/site/test/port-prose.test.ts
@@ -0,0 +1,206 @@
+import { createMarkdownProcessor, parseFrontmatter } from '@astrojs/markdown-remark'
+import { globSync, readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { resolvePortBody, resolvePortContent } from '../src/lib/workspace-shared-slots'
+import { remarkPortCode, resolvePortCode } from '../src/plugins/remark-port-code.mjs'
+import { rehypeSiteRoot } from '../src/plugins/rehype-site-root.mjs'
+import { rehypeApiLinks } from '../src/plugins/rehype-api-links'
+import { proseMentions } from '@libtmux/api-model'
+import { proseHref } from '../src/lib/docs-paths'
+import { docsEntryAvailable } from '../src/lib/page-port-links'
+
+const languageNames: Record<string, string[]> = {
+  py: ['Python'], ts: ['TypeScript'], go: ['Go'], rs: ['Rust'], java: ['Java'],
+  dotnet: ['.NET', 'C#'], cxx: ['C++'], swift: ['Swift'],
+}
+const contentRoot = fileURLToPath(new URL('../src/content/', import.meta.url))
+
+afterEach(() => vi.unstubAllEnvs())
+
+const source = `Common tmux behavior.
+
+<!-- port:root -->
+## Choose a language
+<!-- /port -->
+
+<!-- port:go -->
+<!-- port:root -->
+### Go
+<!-- /port -->
+Use a Go context and check the returned error.
+
+\`\`\`go
+pane.SendKeys(ctx, request)
+\`\`\`
+<!-- /port -->
+
+<!-- port:py -->
+### Python cleanup
+Use the Python context manager.
+
+\`\`\`python
+pane.send_keys("hello")
+\`\`\`
+<!-- /port -->
+
+## Completion
+Sending input does not wait for the program to finish.
+`
+
+describe('port prose ownership', () => {
+  it('retains root comparisons and selects complete port prose', () => {
+    const go = resolvePortBody(source, 'go')
+    expect(go).toContain('Use a Go context')
+    expect(go).toContain('## Completion')
+    expect(go).not.toMatch(/Python|send_keys|Choose a language|### Go|<!--/)
+    const root = resolvePortBody(source, undefined)
+    expect(root).toContain('### Go')
+    expect(root).toContain('### Python cleanup')
+    expect(root).not.toContain('<!--')
+  })
+
+  it('retains explicit ownership for root API links and guide backlinks', async () => {
+    vi.stubEnv('LIBTMUX_DOCS_PORT', '')
+    const body = '## Calls\n\n<!-- port:go -->Use `Session.Panes`.\n<!-- /port -->\n<!-- port:py -->Use `Session.panes`.\n<!-- /port -->'
+    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
+    const rendered = await renderer.render(body)
+    expect(rendered.code).toContain('href="/go/latest/reference/tmux-session-panes/"')
+    expect(rendered.code).toContain('href="/py/latest/reference/libtmux-session-panes/"')
+    const selected = resolvePortContent(body)
+    expect(proseMentions(selected.body, {}, selected.portAt).map(({ port, text }) => ({ port, text }))).toEqual([
+      { port: 'go', text: 'Session.Panes' },
+      { port: 'py', text: 'Session.panes' },
+    ])
+  })
+
+  it('recognizes every supported library without widening workspace ownership', () => {
+    for (const port of ['ruby', 'lua', 'kotlin', 'scala', 'fsharp']) {
+      expect(resolvePortBody(`<!-- port:${port} -->native<!-- /port -->`, port)).toBe('native')
+    }
+  })
+
+  it('treats scope markers inside Markdown demonstrations as literal content', () => {
+    const example = '````markdown\n<!-- port:invalid -->\n```go\nexample\n```\n````\n'
+    expect(resolvePortBody(example, 'go')).toBe(example)
+  })
+
+  it('selects setup commands inside shared console fences', () => {
+    const body = '```console\n<!-- port:go -->$ go test ./...\n<!-- /port --><!-- port:ts -->$ bun test\n<!-- /port -->```'
+    expect(resolvePortBody(body, 'go')).toBe('```console\n$ go test ./...\n```')
+  })
+
+  it('keeps conditional rows in one Markdown table', async () => {
+    const body = '| Port | Call |\n| --- | --- |\n<!-- port:go -->\n| Go | SendKeys |\n<!-- /port -->\n<!-- port:py -->\n| Python | send_keys |\n<!-- /port -->'
+    vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
+    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
+    const rendered = await renderer.render(body)
+    expect(rendered.code.match(/<table>/g)).toHaveLength(1)
+    expect(rendered.code).toContain('<td>SendKeys</td>')
+    expect(rendered.code).not.toContain('Python')
+  })
+
+  it('rejects misspelled, empty and unmatched ownership markers', () => {
+    for (const body of ['<!-- port:golang -->bad<!-- /port -->', '<!-- port: -->bad<!-- /port -->', '<!-- port:go -->bad']) {
+      expect(() => resolvePortBody(body, 'go')).toThrow()
+    }
+  })
+
+  it('resolves every shared workspace source without leaving ownership directives', () => {
+    for (const path of globSync(`${contentRoot}_workspace-shared/**/*.md`)) {
+      for (const port of Object.keys(languageNames)) {
+        expect(resolvePortBody(readFileSync(path, 'utf8'), port), `${port}: ${path}`).not.toMatch(/<!--\s*\/?port/)
+      }
+    }
+  })
+
+  it.each(['ts', 'rs', 'go', 'java', 'dotnet', 'cxx', 'swift'])('keeps native workspace commands on %s pages', (port) => {
+    for (const name of ['index', 'convert', 'edit', 'freeze', 'ls', 'debug-info', 'search', 'load', 'import', 'import-teamocil', 'import-tmuxinator', 'completion', 'shell']) {
+      const raw = readFileSync(`${contentRoot}_workspace-shared/workspace/cli/${name}.md`, 'utf8')
+      const body = resolvePortBody(raw, port)
+      expect(body, `${port}:${name}`).toMatch(/\$ (?:EDITOR=vi )?tmux-workspace /)
+      expect(body, `${port}:${name}`).not.toMatch(/\$ tmuxp |tmuxp compatibility reference|proposed native|seven native ports/i)
+      expect(body, `${port}:${name}`).toContain(`https://github.com/libtmux/libtmux-${port}/blob/`)
+      expect(body, `${port}:${name}`).not.toContain('https://github.com/tmux-python/tmuxp/')
+    }
+  })
+
+  it.each(['ts', 'rs', 'go', 'java', 'dotnet', 'cxx', 'swift'])('keeps every shared workspace guide about %s', (port) => {
+    for (const path of globSync(`${contentRoot}_workspace-shared/workspace/**/*.md`)) {
+      const body = resolvePortBody(readFileSync(path, 'utf8'), port)
+      expect(body, path).not.toMatch(/\$ (?:uv tool install tmuxp|tmuxp )|Python alternative|tmuxp compatibility reference|proposed native|seven native ports|workspace-cli worktree/i)
+      expect(body, path).toContain(`https://github.com/libtmux/libtmux-${port}/blob/`)
+      expect(body, path).not.toContain('https://github.com/tmux-python/tmuxp/')
+      const repositories = [...body.matchAll(/https:\/\/github\.com\/libtmux\/libtmux-([a-z]+)\//g)]
+      expect(repositories.map((match) => match[1]).every((slug) => slug === port), path).toBe(true)
+    }
+  })
+
+  it.each(Object.entries(languageNames))('keeps shared articles specific to %s', (port, ownNames) => {
+    const paths = globSync(`${contentRoot}docs/{concepts,guides,topics,examples}/*.md`)
+    expect(paths.length).toBeGreaterThan(1)
+    for (const path of paths) {
+      const { content: source, frontmatter } = parseFrontmatter(readFileSync(path, 'utf8'))
+      if (!docsEntryAvailable({ id: path.slice(`${contentRoot}docs/`.length).replace(/\.md$/, ''), data: frontmatter }, port)) continue
+      const prose = resolvePortCode(source, port).replace(/^ *```[\s\S]*?^ *```.*$/gm, '')
+      const names = [...prose.matchAll(/\b(?:Python|TypeScript|Go|Rust|Java|Swift)\b|\.NET|C\+\+|C#/g)].map((match) => match[0])
+      expect(names.filter((name) => !ownNames.includes(name)), path).toEqual([])
+    }
+  })
+
+  it('removes foreign headings and prose before HTML and heading metadata are generated', async () => {
+    vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
+    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
+    const rendered = await renderer.render(source)
+    expect(rendered.code).toContain('Use a Go context')
+    expect(rendered.code).not.toMatch(/Python|send_keys|Choose a language|### Go/)
+    expect(rendered.metadata.headings.map((heading) => heading.text)).toEqual(['Completion'])
+  })
+
+  it('does not read a missing source example that belongs to another port', async () => {
+    vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
+    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
+    const rendered = await renderer.render('```python file="missing/unselected.py"\n```\n\n```go\nselected()\n```')
+    expect(rendered.code).toContain('selected()')
+  })
+
+  it('keeps nested fence delimiters intact in Markdown exports', () => {
+    const body = '~~~python\nforeign()\n~~~\n\n````markdown\n```python\nliteral()\n```\n````'
+    expect(resolvePortCode(body, 'go')).toBe('\n````markdown\n```python\nliteral()\n```\n````')
+  })
+
+  it('keeps article links in the selected version in HTML and Markdown', async () => {
+    vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
+    vi.stubEnv('LIBTMUX_DOCS_VERSION', 'v0.1')
+    vi.stubEnv('LIBTMUX_DOCS_ROOT', '/pr-42/en/')
+    const body = '[Task](/guides/sending-keys/)\n\n`[literal](/guides/x/)`\n\n```go\n// [literal](/guides/x/)\n```'
+    const renderer = await createMarkdownProcessor({ rehypePlugins: [rehypeSiteRoot], syntaxHighlight: false })
+    expect((await renderer.render(body)).code).toContain('href="/pr-42/en/go/v0.1/guides/sending-keys/"')
+    const markdown = resolvePortCode(body, 'go', undefined, (href: string) => proseHref(href, '/pr-42/en', 'go', 'v0.1'))
+    expect(markdown).toContain('[Task](/pr-42/en/go/v0.1/guides/sending-keys/)')
+    expect(markdown).toContain('`[literal](/guides/x/)`')
+    expect(markdown).toContain('// [literal](/guides/x/)')
+    expect(proseHref('/guides/sending-keys/', '/en')).toBe('/en/guides/sending-keys/')
+    expect(proseHref('/py/latest/', '/en', 'go')).toBe('/en/py/latest/')
+  })
+
+  it.each(['pane-interaction', 'options-and-hooks'])('curates the %s article in HTML and machine-readable text', async (name) => {
+    const raw = readFileSync(new URL(`../src/content/docs/topics/${name}.md`, import.meta.url), 'utf8')
+    const body = raw.replace(/^---\n[\s\S]*?\n---\n/, '')
+    vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
+    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
+    const rendered = await renderer.render(body)
+    const markdown = resolvePortCode(body, 'go')
+    for (const output of [rendered.code, markdown]) {
+      expect(output).not.toMatch(/Python|TypeScript|Rust|Java|\.NET|C\+\+|Swift|pane\.send_keys|pane\.show_options/)
+      expect(output).toContain('ctx')
+    }
+    expect(rendered.metadata.headings.map((heading) => heading.text)).not.toContain('Go')
+    vi.stubEnv('LIBTMUX_DOCS_PORT', '')
+    const rootRenderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
+    const root = await rootRenderer.render(body)
+    expect(root.code).toContain('Python')
+    expect(root.code).toContain('language-python')
+    expect(root.code).toContain('language-go')
+  })
+})
diff --git a/site/test/product-docs.test.ts b/site/test/product-docs.test.ts
index 079ec2c0..4dc953e4 100644
--- a/site/test/product-docs.test.ts
+++ b/site/test/product-docs.test.ts
@@ -50,9 +50,10 @@ it('advertises local native loaders while retaining their development status', (
     if (!native(port)) expect(port.workspaceCliAvailability).toBe('released')
     expect(productInDevelopment(port, 'workspace')).toBe(native(port))
     expect(productInDevelopment(port, 'mcp')).toBe(true)
-    if (port.workspaceCliAvailability === 'local') expect(productDescription(port, 'workspace')).toContain('local workspace-cli worktree')
+    expect(productDescription(port, 'workspace')).not.toMatch(/worktree|checkpoint/)
+    if (port.workspaceCliAvailability === 'local') expect(productDescription(port, 'workspace')).toContain('Build the CLI from source')
     if (port.workspaceCliAvailability === 'published') {
-      expect(productDescription(port, 'workspace')).toContain('published prerelease')
+      expect(productDescription(port, 'workspace')).toContain('prerelease')
       expect(workspaceOverviewNotice(port)?.body).not.toMatch(/unreleased|local/)
     }
   }
@@ -242,7 +243,8 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
         const language = attribute(tags(block, 'pre')[0] ?? '', 'data-language')?.toLowerCase()
         const owner = language && LANG_TO_PORT[language]
         const caption = block.match(/<figcaption\b[^>]*>([\s\S]*?)<\/figcaption>/i)?.[1] ?? ''
-        const buildScript = page.port === 'java' && language === 'kotlin' && text(caption) === 'build.gradle.kts'
+        const buildScript = page.port === 'java' && language === 'kotlin'
+          && ['settings.gradle.kts', 'build.gradle.kts'].includes(text(caption))
         if (owner && !buildScript) expect(owner, `${page.path} foreign language example`).toBe(page.port)
       }
       const headings = [...article!.matchAll(/<h[23]\b[^>]*>([\s\S]*?)<\/h[23]>/gi)].map((match) => text(match[1]!))
@@ -330,12 +332,12 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
           .find((text) => /in development/i.test(text))
         expect(status, `${page.path} development status`).toBeDefined()
         const article = document.querySelector('article')!.textContent
-        if (port.workspaceCliAvailability === 'local') expect(article, `${page.path} local CLI worktree`).toContain('workspace-cli')
+        if (port.workspaceCliAvailability === 'local') expect(article, `${page.path} source installation`).toContain('from the source revision in the installation guide')
         expect(article, `${page.path} native CLI`).toContain('tmux-workspace')
         expect(article.match(/is in development/gi), `${page.path} states maturity once`).toHaveLength(1)
-        const upstream = [...document.querySelectorAll('article a[href]')]
-          .find((link) => link.getAttribute('href') === 'https://tmuxp.git-pull.com/')
-        expect(upstream?.textContent, `${page.path} tmuxp reference`).toBe('tmuxp')
+        const links = [...document.querySelectorAll('article a[href]')]
+        expect(links.some((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname === urlFor(`${page.port}/${page.version}/workspace/guides/installation/`).pathname), `${page.path} native installation`).toBe(true)
+        expect(links.some((link) => link.getAttribute('href') === 'https://tmuxp.git-pull.com/'), `${page.path} foreign installation`).toBe(false)
       }
     })
   })
@@ -484,7 +486,10 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
       const body = read(`${root}llms-full.txt`)
       expect(body, `${root} resolved file inclusions`).not.toMatch(/```[^\n]*file="[^"\n]+"[^\n]*\n\s*```/)
       const exported = JSON.parse(read(`${root}docs.json`)) as DocsManifest
-      for (const port of PORTS) {
+      const [rootPort, rootVersion] = root.split('/')
+      const visiblePorts = PORTS.filter((port) => !rootPort || port.slug === rootPort)
+      expect(exported.ports.map((port) => port.slug), `${root} port scope`).toEqual(visiblePorts.map((port) => port.slug))
+      for (const port of visiblePorts) {
         const advertised = exported.ports.find((entry) => entry.slug === port.slug)!
         if (port.parentLibrary) {
           expect(advertised.products, `${port.slug} is library-only`).toEqual([])
@@ -496,7 +501,7 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
           expect(metadata.inDevelopment, `${root}${port.slug} ${product} development status`).toBe(productInDevelopment(port, product))
           const section = 'reference'
           if (productAvailable(port, product)) {
-            expect(new URL(metadata.reference!, urlFor(root)).pathname).toBe(urlFor(`${port.slug}/${defaults[port.slug]}/${product}/${section}/`).pathname)
+            expect(new URL(metadata.reference!, urlFor(root)).pathname).toBe(urlFor(`${port.slug}/${rootVersion || defaults[port.slug]}/${product}/${section}/`).pathname)
           } else expect(metadata.reference).toBeNull()
           if (product === 'workspace') {
             expect(metadata.cli, `${root}${port.slug} user CLI`).toBe(port.workspaceCli ?? null)
@@ -505,17 +510,17 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
           else expect(metadata.protocol).toBeNull()
         }
       }
-      const ruby = exported.ports.find((entry) => entry.slug === 'ruby')!
-      expect(ruby.documentation).toEqual(expect.arrayContaining([
+      const ruby = exported.ports.find((entry) => entry.slug === 'ruby')
+      if (ruby) expect(ruby.documentation).toEqual(expect.arrayContaining([
         expect.objectContaining({ id: 'async', kind: 'companion-package', availability: 'available', package: 'libtmux-async' }),
       ]))
-      const lua = exported.ports.find((entry) => entry.slug === 'lua')!
-      expect(lua.documentation).toEqual(expect.arrayContaining([
+      const lua = exported.ports.find((entry) => entry.slug === 'lua')
+      if (lua) expect(lua.documentation).toEqual(expect.arrayContaining([
         expect.objectContaining({ id: 'runtime', kind: 'runtime', availability: 'available' }),
         expect.objectContaining({ id: 'mcp', kind: 'unavailable', availability: 'unpublished' }),
         expect.objectContaining({ id: 'workspace', kind: 'unavailable', availability: 'unpublished' }),
       ]))
-      for (const area of [...ruby.documentation, ...lua.documentation]) {
+      for (const area of exported.ports.flatMap((port) => port.documentation)) {
         expect(resolves(area.url, urlFor(root).href), `${root}${area.url} documentation area`).toBe(true)
       }
       for (const entry of exported.pages.filter((entry) => productUrl.test(entry.url))) {
diff --git a/site/test/search-index.test.ts b/site/test/search-index.test.ts
index d28f554b..32903e74 100644
--- a/site/test/search-index.test.ts
+++ b/site/test/search-index.test.ts
@@ -1,7 +1,22 @@
 import { readFileSync } from 'node:fs'
 import { Window } from 'happy-dom'
 import { expect, it } from 'vitest'
-import { SITE_BUILT, sitePath } from './site-root'
+import { SITE_BUILT, SITE_PREFIX, sitePath } from './site-root'
+import { PORTS } from '../src/lib/ports'
+
+it.skipIf(!SITE_BUILT)('starts port search in that language and leaves root search unfiltered', () => {
+  for (const port of PORTS) {
+    for (const route of ['search', 'reference']) {
+      const html = readFileSync(sitePath(port.slug, 'latest', route, 'index.html'), 'utf8')
+      expect(html, `${port.slug}/${route} search scope`).toContain(`data-initial-port="${port.name}"`)
+    }
+  }
+  const root = readFileSync(sitePath('search/index.html'), 'utf8')
+  expect(root).not.toContain('data-initial-port=')
+  const symbols = readFileSync(sitePath('reference/symbols/a/index.html'), 'utf8')
+  expect(symbols).toContain(`data-search-href="/${SITE_PREFIX}search/"`)
+  expect(symbols).not.toContain('/symbols/latest/search/')
+})
 
 it.skipIf(!SITE_BUILT)('indexes scoped product declarations while retaining core, internal, and index pages', () => {
   const cases = [
diff --git a/site/test/search-panel.test.ts b/site/test/search-panel.test.ts
new file mode 100644
index 00000000..f820b450
--- /dev/null
+++ b/site/test/search-panel.test.ts
@@ -0,0 +1,118 @@
+import { Window } from 'happy-dom'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { mountSearchPanel, type PagefindApi, type PagefindResultData } from '../src/lib/search-panel'
+
+let window: Window
+afterEach(() => {
+  vi.unstubAllGlobals()
+  window?.close()
+})
+
+function fixture(initialPort?: string) {
+  window = new Window({ url: 'https://libtmux.org/en/go/latest/search/' })
+  vi.stubGlobal('document', window.document)
+  vi.stubGlobal('Event', window.Event)
+  window.document.body.innerHTML = `<div class="search-panel">
+    <input class="search-panel__input">
+    <aside class="search-panel__filters" hidden><div class="search-panel__filter-list"></div></aside>
+    <div class="search-panel__results"></div>
+  </div>`
+  // Happy DOM implements the browser API with its own element types.
+  const root = window.document.querySelector('.search-panel')! as unknown as HTMLElement
+  const input = root.querySelector<HTMLInputElement>('input')!
+  const pages = ['Go', 'Rust'].map((port) => ({ port, data: {
+    url: `/en/${port === 'Go' ? 'go' : 'rs'}/latest/topics/capture/`,
+    excerpt: `${port} capture`, meta: { title: `${port} capture` },
+  } }))
+  const search = vi.fn<PagefindApi['search']>(async (query, options) => {
+    const ports = (options?.filters as { port?: string[] } | undefined)?.port
+    const hits = query === 'capture' ? pages.filter((page) => !ports || ports.includes(page.port)) : []
+    const counts: Record<string, number> = query === 'capture' ? { Go: 1, Rust: 1 } : {}
+    return {
+      results: hits.map((page) => ({ id: page.port, data: async () => page.data })),
+      totalFilters: { port: counts },
+    }
+  })
+  const filters = vi.fn<PagefindApi['filters']>(async () => ({ port: { Go: 1, Rust: 1 } }))
+  const handle = mountSearchPanel(root, '/en/pagefind/', {
+    initialPort, initialQuery: 'capture', mock: { search, filters },
+  })
+  const query = (value: string) => {
+    input.value = value
+    input.dispatchEvent(new Event('input', { bubbles: true }))
+  }
+  const results = () => [...root.querySelectorAll<HTMLAnchorElement>('.search-panel__result')].map((link) => link.getAttribute('href'))
+  const filter = (port: string) => root.querySelector<HTMLInputElement>(`input[value="${port}"]`)!
+  return { root, search, filters, handle, query, results, filter }
+}
+
+describe('port search defaults', () => {
+  it('filters the first query, keeps a selected port with zero hits, and preserves it when reopened', async () => {
+    const { search, handle, query, results, filter } = fixture('Go')
+    await vi.waitFor(() => expect(results()).toEqual(['/en/go/latest/topics/capture/']))
+    expect(search).toHaveBeenNthCalledWith(1, 'capture', { filters: { port: ['Go'] } })
+    expect(filter('Go').checked).toBe(true)
+    query('absent')
+    await vi.waitFor(() => expect(results()).toEqual([]))
+    expect(filter('Go').checked).toBe(true)
+    handle.clear()
+    query('capture')
+    await vi.waitFor(() => expect(results()).toEqual(['/en/go/latest/topics/capture/']))
+  })
+
+  it('lets a reader broaden or change the scope without restoring the initial port', async () => {
+    const { query, results, filter } = fixture('Go')
+    await vi.waitFor(() => expect(results()).toHaveLength(1))
+    filter('Go').checked = false
+    filter('Go').dispatchEvent(new Event('change'))
+    await vi.waitFor(() => expect(results()).toHaveLength(2))
+    filter('Rust').checked = true
+    filter('Rust').dispatchEvent(new Event('change'))
+    await vi.waitFor(() => expect(results()).toEqual(['/en/rs/latest/topics/capture/']))
+    query('absent')
+    await vi.waitFor(() => expect(results()).toEqual([]))
+    expect(filter('Rust').checked).toBe(true)
+  })
+
+  it('leaves the root search across all ports', async () => {
+    const { search, results, filter } = fixture()
+    await vi.waitFor(() => expect(results()).toHaveLength(2))
+    expect(search).toHaveBeenCalledWith('capture', { filters: undefined })
+    expect(filter('Go').checked).toBe(false)
+    expect(filter('Rust').checked).toBe(false)
+  })
+
+  it('keeps query counts when an older idle filter inventory finishes', async () => {
+    const { root, filters, handle, query, results, filter } = fixture('Go')
+    await vi.waitFor(() => expect(results()).toHaveLength(1))
+    let release: (counts: Record<string, Record<string, number>>) => void = () => {}
+    filters.mockReturnValueOnce(new Promise((resolve) => { release = resolve }))
+    handle.clear()
+    await vi.waitFor(() => expect(filters).toHaveBeenCalledOnce())
+    query('capture')
+    await vi.waitFor(() => expect(results()).toEqual(['/en/go/latest/topics/capture/']))
+    const counts = () => [...root.querySelectorAll('.search-panel__filter-count')].map((count) => count.textContent)
+    expect(counts()).toEqual(['1', '1'])
+    release({ port: { Go: 100, Rust: 200 } })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(counts()).toEqual(['1', '1'])
+    expect(filter('Go').checked).toBe(true)
+    expect(results()).toEqual(['/en/go/latest/topics/capture/'])
+  })
+
+  it('does not paint an old result after the reader changes the query', async () => {
+    const { search, query, results, root } = fixture('Go')
+    await vi.waitFor(() => expect(results()).toHaveLength(1))
+    let release: (data: PagefindResultData) => void = () => {}
+    const data = vi.fn(() => new Promise<PagefindResultData>((resolve) => { release = resolve }))
+    search.mockResolvedValueOnce({ results: [{ id: 'slow', data }] })
+    query('slow')
+    await vi.waitFor(() => expect(data).toHaveBeenCalled())
+    query('absent')
+    await vi.waitFor(() => expect(root.textContent).toContain('No results for absent.'))
+    release({ url: '/en/rs/latest/', excerpt: 'Stale', meta: { title: 'Stale' } })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(results()).toEqual([])
+    expect(root.textContent).toContain('No results for absent.')
+  })
+})
diff --git a/site/test/stage-port-docs.outer.test.ts b/site/test/stage-port-docs.outer.test.ts
new file mode 100644
index 00000000..a9423920
--- /dev/null
+++ b/site/test/stage-port-docs.outer.test.ts
@@ -0,0 +1,117 @@
+import { execFileSync, spawnSync } from 'node:child_process'
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { expect, it } from 'vitest'
+import { stagedRoutesFor } from '../../scripts/stage-port-docs.mjs'
+import { PORTS } from '../src/lib/ports.ts'
+
+const root = new URL('../../', import.meta.url).pathname
+const cachedRevision = 'a'.repeat(40)
+const files = ['scripts/stage-port-docs.mjs', 'site/src/lib/ports.ts',
+  'site/src/lib/site-root.ts', 'site/src/lib/cooldown.ts', 'site/src/lib/port-documentation.ts']
+const stagedPorts = ['ruby', 'lua', 'kotlin', 'scala', 'fsharp']
+
+function fixture(slug: 'ruby' | 'lua' | 'kotlin', run: (fixture: {
+  directory: string; checkout: string; revision: string;
+  write: (path: string, value: string) => void;
+  artifact: (port: string, revision: string, label: string) => string;
+  invoke: (...args: string[]) => ReturnType<typeof invokeGenerator>;
+}) => void) {
+  const directory = mkdtempSync(join(tmpdir(), 'libtmux-staged-publication-'))
+  const checkout = join(directory, 'source')
+  const write = (path: string, value: string) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, value) }
+  const artifact = (port: string, revision: string, label: string) => JSON.stringify({
+    source: { repository: PORTS.find((entry) => entry.slug === port)!.repo, revision },
+    guides: Object.keys(stagedRoutesFor(port)).map((path) => ({ path, content: `# Guide\n\n${label}-${port}\n` })),
+  })
+  try {
+    for (const file of files) {
+      mkdirSync(dirname(join(directory, file)), { recursive: true })
+      copyFileSync(join(root, file), join(directory, file))
+    }
+    symlinkSync(join(root, 'node_modules'), join(directory, 'node_modules'), 'dir')
+    write(join(directory, 'package.json'), '{"type":"module"}')
+    for (const port of stagedPorts) {
+      write(join(directory, `site/src/data/port-guides/${port}.json`), artifact(port, cachedRevision, 'cached'))
+      if (port === 'ruby' || port === 'lua') write(join(directory, `site/src/data/api/${port}.json`), JSON.stringify({ revision: cachedRevision }))
+    }
+    let revision = 'b'.repeat(40)
+    if (slug === 'kotlin') {
+      for (const path of Object.keys(stagedRoutesFor(slug))) write(join(checkout, path), '# Guide\n\nfresh-kotlin\n')
+      const git = (...args: string[]) => execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: 'pipe' }).trim()
+      git('init', '-q')
+      git('add', '.')
+      git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '-qm', 'Selected source')
+      revision = git('rev-parse', 'HEAD')
+    }
+    const env = { ...process.env, LIBTMUX_DOCS_PORT: slug, LIBTMUX_DOCS_SOURCE_SHA: revision,
+      [`LIBTMUX_DOCS_CHECKOUT_${slug.toUpperCase()}`]: checkout }
+    run({ directory, checkout, revision, write, artifact,
+      invoke: (...args) => invokeGenerator(directory, env, args) })
+  } finally {
+    rmSync(directory, { recursive: true, force: true })
+  }
+}
+
+function invokeGenerator(directory: string, env: NodeJS.ProcessEnv, args: string[]) {
+  return spawnSync(process.execPath, [join(directory, 'scripts/stage-port-docs.mjs'), ...args],
+    { encoding: 'utf8', env, timeout: 10000 })
+}
+
+it.each(['ruby', 'lua', 'kotlin'] as const)('stages other caches before accepting only the selected %s source', (slug) => {
+  fixture(slug, ({ directory, checkout, revision, write, artifact, invoke }) => {
+    const staged = join(directory, 'site/src/content/docs/_staged')
+    const cache = join(directory, `site/src/data/port-guides/${slug}.json`)
+    const cachedBytes = readFileSync(cache, 'utf8')
+    const otherCaches = Object.fromEntries(stagedPorts.filter((port) => port !== slug)
+      .map((port) => [port, readFileSync(join(directory, `site/src/data/port-guides/${port}.json`), 'utf8')]))
+    const baseline = invoke('--cached')
+    expect(baseline.status, baseline.stderr).toBe(0)
+    expect(existsSync(join(staged, slug))).toBe(false)
+    expect(readFileSync(cache, 'utf8')).toBe(cachedBytes)
+    for (const port of stagedPorts.filter((port) => port !== slug)) {
+      const route = Object.values(stagedRoutesFor(port))[0].route
+      expect(readFileSync(join(staged, port, route, 'index.md'), 'utf8')).toContain(`cached-${port}`)
+    }
+
+    const explicit = invoke('--cached', '--port', slug)
+    expect(explicit.status).not.toBe(0)
+    expect(explicit.stderr).toContain(`--cached cannot stage selected publication port ${slug}`)
+    expect(readFileSync(cache, 'utf8')).toBe(cachedBytes)
+
+    if (slug !== 'kotlin') {
+      write(join(directory, `site/src/data/api/${slug}.json`), JSON.stringify({ revision }))
+      write(join(checkout, 'docs/_build/api.json'), artifact(slug, revision, 'fresh'))
+    }
+    const fresh = invoke('--port', slug, ...(slug === 'kotlin' ? ['--from-source'] : []))
+    expect(fresh.status, fresh.stderr).toBe(0)
+    const route = Object.values(stagedRoutesFor(slug))[0].route
+    const rendered = join(staged, slug, route, 'index.md')
+    expect(readFileSync(rendered, 'utf8')).toContain(`fresh-${slug}`)
+    expect(readFileSync(rendered, 'utf8')).toContain(revision)
+    expect(JSON.parse(readFileSync(cache, 'utf8')).source.revision).toBe(revision)
+    const wrappers = invoke('--wrappers')
+    expect(wrappers.status, wrappers.stderr).toBe(0)
+    const renderedBytes = readFileSync(rendered, 'utf8')
+    expect(renderedBytes).toContain(`fresh-${slug}`)
+    expect(renderedBytes).toContain(revision)
+    for (const [port, bytes] of Object.entries(otherCaches)) {
+      expect(readFileSync(join(directory, `site/src/data/port-guides/${port}.json`), 'utf8')).toBe(bytes)
+    }
+
+    const wrong = 'c'.repeat(40)
+    if (slug === 'kotlin') {
+      execFileSync('git', ['-C', checkout, '-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid',
+        'commit', '--allow-empty', '-qm', 'Different source'], { stdio: 'pipe' })
+    } else {
+      write(join(directory, `site/src/data/api/${slug}.json`), JSON.stringify({ revision: wrong }))
+      write(join(checkout, 'docs/_build/api.json'), artifact(slug, wrong, 'wrong'))
+    }
+    const rejected = invoke('--port', slug, ...(slug === 'kotlin' ? ['--from-source'] : []))
+    expect(rejected.status).not.toBe(0)
+    expect(rejected.stderr).toContain(`${slug}: expected source ${revision}, artifact records`)
+    expect(readFileSync(rendered, 'utf8')).toBe(renderedBytes)
+    expect(JSON.parse(readFileSync(cache, 'utf8')).source.revision).toBe(revision)
+  })
+})
diff --git a/site/test/stage-port-docs.test.ts b/site/test/stage-port-docs.test.ts
index 37fd7c0a..508cfce1 100644
--- a/site/test/stage-port-docs.test.ts
+++ b/site/test/stage-port-docs.test.ts
@@ -1,5 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { rewriteLinks, stagedPortGuides, stagedRoutesFor } from '../../scripts/stage-port-docs.mjs'
+import scalaGuides from '../src/data/port-guides/scala.json'
+import fsharpGuides from '../src/data/port-guides/fsharp.json'
 
 describe('staged port guide links', () => {
   const routes = {
@@ -47,6 +49,46 @@ describe('staged port guide links', () => {
     expect(result).toContain('[query](../query/#filters)')
   })
 
+  it('keeps known source-guide URLs in the selected documentation tree', () => {
+    const own = 'https://github.com/libtmux/libtmux-lua/blob/'
+    const historical = `${own}older/docs/query.md`
+    const otherRepo = 'https://github.com/other/project/blob/master/docs/query.md'
+    const example = `\`${own}master/docs/query.md\``
+    const result = rewriteLinks(
+      `[current](${own}master/docs/query.md#filters) [main](${own}main/docs/query.md) `
+        + `[pinned](${own}abc123/docs/query.md) [old](${historical}) [other](${otherRepo}) ${example}`,
+      'docs/runtime.md', 'guides/source/runtime', routes, 'libtmux/libtmux-lua', 'abc123',
+    )
+    expect(result).toContain('[current](../query/#filters)')
+    expect(result).toContain('[main](../query/)')
+    expect(result).toContain('[pinned](../query/)')
+    expect(result).toContain(`[old](${historical})`)
+    expect(result).toContain(`[other](${otherRepo})`)
+    expect(result).toContain(example)
+  })
+
+  it('routes the actual F# quickstart to its staged task guides', () => {
+    const staged = stagedPortGuides('fsharp', fsharpGuides).get('fsharp/guides/quickstart/index.md')!
+    for (const route of ['getting-started', 'queries', 'streams', 'supported-query-fields', 'modes', 'interop']) {
+      expect(staged).toContain(`](../${route}/)`)
+    }
+    expect(staged).toContain('](../../reference/)')
+    expect(staged).not.toMatch(/https:\/\/github.com\/libtmux\/libtmux-dotnet\/blob\/master\/docs\/fsharp\//)
+    expect(staged).toContain(`https://github.com/libtmux/libtmux-dotnet/blob/${fsharpGuides.source.revision}/examples/LibTmux.FSharp.Quickstart/Program.fs`)
+  })
+
+  it('pins non-staged source links while preserving historical links and inline images', () => {
+    const own = 'https://github.com/libtmux/libtmux-lua/blob/'
+    const destinations = ['master', 'main', 'abc123'].map((ref) => `[source](${own}${ref}/src/main.lua#run)`)
+    const image = `![source](${own}master/art/example.png)`
+    const historical = `[old](${own}older/src/main.lua#run)`
+    const result = rewriteLinks([...destinations, image, historical].join('\n\n'),
+      'docs/runtime.md', 'guides/source/runtime', routes, 'libtmux/libtmux-lua', 'abc123')
+    expect(result.match(/\[source\]\(https:\/\/github.com\/libtmux\/libtmux-lua\/blob\/abc123\/src\/main.lua#run\)/g)).toHaveLength(3)
+    expect(result).toContain(image)
+    expect(result).toContain(historical)
+  })
+
   it('rewrites Scala reference links across lines without changing external links', () => {
     const result = rewriteLinks(
       '[query]: query.md#filters\n[source]:\n  ../src/Server.scala\n[external]: https://example.org/\n',
@@ -57,6 +99,44 @@ describe('staged port guide links', () => {
     expect(result).toContain('[external]: https://example.org/')
   })
 
+  it('preserves code while rewriting real links beside it', () => {
+    const examples = [
+      '```scala\nScalaServer.fromJava[IO](java).use(identity)\n```',
+      '~~~~scala\nScalaServer.resource[IO](config).use(identity)\n~~~~',
+      '> ```scala\n> Control.attach[IO](session)\n> ```',
+      '    Server.resource[IO](config)',
+      '`Server.resource[IO](config)` and ``[query](query.md)``',
+      '\\[query](query.md)',
+    ]
+    const content = `${examples.join('\n\n')}\n\n[query](query.md#filters "Read filters")\n`
+    const result = rewriteLinks(content, 'docs/runtime.md', 'guides/source/runtime', routes,
+      'libtmux/libtmux-java', 'abc123')
+    for (const example of examples) expect(result).toContain(example)
+    expect(result).toContain('[query](../query/#filters "Read filters")')
+    expect(result).not.toContain('/docs/config')
+    expect(result).not.toContain('/docs/java')
+    expect(result).not.toContain('/docs/session')
+  })
+
+  it('rewrites images nested in links without damaging their labels', () => {
+    const result = rewriteLinks('[![example](../art/example.png "Example")](query.md#filters)',
+      'docs/runtime.md', 'guides/source/runtime', routes, 'libtmux/libtmux-java', 'abc123')
+    expect(result).toContain('[![example](https://github.com/libtmux/libtmux-java/raw/abc123/art/example.png "Example")](../query/#filters)')
+  })
+
+  it('stages the actual Scala generic calls unchanged', () => {
+    const files = stagedPortGuides('scala', scalaGuides)
+    for (const [route, calls] of [
+      ['ownership', ['ScalaServer.fromJava[IO](java)']],
+      ['execution', ['ScalaServer.resource[IO](config)']],
+      ['streaming', ['Server.resource[IO](config)', 'Control.attach[IO](session)']],
+    ] as const) {
+      const staged = files.get(`scala/guides/${route}/index.md`)!
+      for (const call of calls) expect(staged).toContain(call)
+      expect(staged).not.toContain('[IO](https://')
+    }
+  })
+
   it('extracts centered README titles without losing links or examples', () => {
     const header = [
       '<!-- libtmux-logo -->', '<p>artwork</p>', '<!-- /libtmux-logo -->', '',
@@ -73,6 +153,8 @@ describe('staged port guide links', () => {
       guides,
     })
     const overview = files.get('ruby/guides/overview/index.md')!
+    expect(files.get('ruby/examples/index.md')).toContain('../examples/recipes/')
+    expect(files.get('ruby/topics/index.md')).toContain('../guides/execution-modes/')
     expect(overview).toContain('title: "libtmux for Ruby"')
     expect(overview).not.toContain('# libtmux for Ruby')
     expect(overview).not.toContain('artwork')
diff --git a/site/test/workspace-shared.test.ts b/site/test/workspace-shared.test.ts
index 3e6bc964..18023c79 100644
--- a/site/test/workspace-shared.test.ts
+++ b/site/test/workspace-shared.test.ts
@@ -4,8 +4,8 @@ import { parseSlots, resolvePortBody, resolvePortData, resolveSlots } from '../s
 describe('workspace-shared slots', () => {
   it('keeps unmarked text and a matching port, drops a non-matching one', () => {
     const raw = 'shared\n<!-- port:go -->\ngo only\n<!-- /port -->\nafter'
-    expect(resolvePortBody(raw, 'go')).toBe('shared\n\ngo only\n\nafter')
-    expect(resolvePortBody(raw, 'ts')).toBe('shared\n\nafter')
+    expect(resolvePortBody(raw, 'go')).toBe('shared\ngo only\nafter')
+    expect(resolvePortBody(raw, 'ts')).toBe('shared\nafter')
   })
 
   it('resolves nested blocks against the innermost matching scope', () => {
diff --git a/site/test/wrapper-libraries.test.ts b/site/test/wrapper-libraries.test.ts
index 23f4ea68..bd838c46 100644
--- a/site/test/wrapper-libraries.test.ts
+++ b/site/test/wrapper-libraries.test.ts
@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import { PORTS, PORT_BY_SLUG, productAvailable } from '../src/lib/ports'
+import { PORTS, PORT_BY_SLUG, portSourceUrl, productAvailable } from '../src/lib/ports'
 import { documentationAreas } from '../src/lib/port-documentation'
 import { LANG_TO_PORT, remarkPortCode } from '../src/plugins/remark-port-code.mjs'
 import { QUICKSTARTS } from '../src/lib/quickstarts'
@@ -47,6 +47,23 @@ describe('wrapper library identities', () => {
     }
   })
 
+  it.each(['kotlin', 'scala'])('opens the %s source directory without changing its repository identity', (slug) => {
+    const port = PORT_BY_SLUG[slug]
+    const root = `https://github.com/libtmux/libtmux-java/tree/`
+    const path = `/libtmux-${slug}`
+    expect(port.repo).toBe('libtmux/libtmux-java')
+    expect(portSourceUrl(port)).toBe(`${root}master${path}`)
+    expect(portSourceUrl(port, 'v0.0.1-alpha.17')).toBe(`${root}v0.0.1-alpha.17${path}`)
+    for (const version of ['latest', 'stable', 'next', 'pr-42', 'v0.0.1-alpha.17']) {
+      expect(portSourceUrl(port, version, 'a'.repeat(40))).toBe(`${root}${'a'.repeat(40)}${path}`)
+    }
+    for (const version of ['stable', 'next', 'pr-42']) {
+      expect(portSourceUrl(port, version)).toBe(`${root}master${path}`)
+    }
+    expect(portSourceUrl(port, 'latest', 'feature/source-links')).toBe(`${root}feature%2Fsource-links${path}`)
+    expect(portSourceUrl(PORT_BY_SLUG.java, 'v0.0.1-alpha.17', 'a'.repeat(40))).toBe('https://github.com/libtmux/libtmux-java')
+  })
+
   it('supplies native examples and registry versions in the library installer', () => {
     for (const { slug } of wrappers) {
       const port = PORT_BY_SLUG[slug]
@@ -113,6 +130,8 @@ describe.skipIf(!SITE_BUILT)('published wrapper pages', () => {
           expect(logo?.getAttribute('src')).toContain(`/brand/${port.logoLanguage}/library/logo.svg`)
           expect(logo?.getAttribute('width')).toBe('88')
           expect(document.querySelector('main')?.textContent).toContain(PORT_BY_SLUG[port.parentLibrary!.slug].name)
+          expect(document.querySelector('.port-links a')?.getAttribute('href')).toBe(portSourceUrl(port))
+          expect(document.querySelector('footer a[aria-label="GitHub"]')?.getAttribute('href')).toBe(`${portSourceUrl(port)}${port.source ? '' : '/'}`)
         }
       } finally { await window.happyDOM.close() }
     }