← All changes | includes/core/payload.php +1603 -310 0.9.8 → 1.1.13 View file →

		@@ -1,7 +1,7 @@
1	1	<?php
2	2	/**
3		- * Desktop Mode — payload building helpers.
	3	+ * OpenStation — payload building helpers.
4	4	*
5	5	* Dock-item construction, native-window payload assembly, menu
6	6	* payload (the data the shell shows in the dock + on bootstrap),
7	7	* and the script/style handle resolvers used by the live-refresh
		@@ -13,9 +13,9 @@
13	13	* still fires with the same shape — PHP looks function references
14	14	* up by name at hook-fire time, so existing callers continue to
15	15	* resolve regardless of which file owns the definition.
16	16	*
17		- * @package Desktop_Mode
	17	+ * @package OpenStation
18	18	*/
19	19
20	20	defined( 'ABSPATH' ) || exit;
21	21
		@@ -29,9 +29,9 @@
29	29	*
30	30	* @return array[] Array of dock item arrays, each containing:
31	31	* id, title, icon, url, badge, submenu.
32	32	*/
33		-function desktop_mode_build_dock_items() {
	33	+function openstation_build_dock_items() {
34	34	global $menu, $submenu;
35	35
36	36	if ( empty( $menu ) ) {
37	37	return array();
		@@ -54,12 +54,18 @@
54	54	if ( ! empty( $item[1] ) && ! current_user_can( $item[1] ) ) {
55	55	continue;
56	56	}
57	57
58		- // Extract the clean title: strip badge spans first, then strip remaining tags.
59		- $raw_title = preg_replace( '/<span[^>]*>.*?<\/span>/s', '', $item[0] );
60		- $title = trim( wp_strip_all_tags( $raw_title ) );
	58	+ // Skip menus something took out of the classic sidebar. A dock
	59	+ // that shows what wp-admin hides isn't a faithful mirror of the
	60	+ // menu, and on WordPress.com it double-renders every entry
	61	+ // Jetpack replaced with a Calypso link.
	62	+ if ( openstation_menu_item_is_hidden( $item ) ) {
	63	+ continue;
	64	+ }
61	65
	66	+ $title = openstation_menu_item_title( $item[0] );
	67	+
62	68	// Extract badge count from the title HTML.
63	69	$badge = 0;
64	70	if ( preg_match( '/class="(?:update-plugins|awaiting-mod)[^"]*count-(\d+)"/', $item[0], $matches ) ) {
65	71	$badge = (int) $matches[1];
		@@ -77,17 +83,29 @@
77	83	// dock count always agrees with what the window shows (GH#258).
78	84	if (
79	85	'plugins.php' === $item[2] &&
80	86	! is_multisite() &&
81		- function_exists( 'desktop_mode_plugins_window_count_visible_updates' )
	87	+ function_exists( 'openstation_plugins_window_count_visible_updates' )
82	88	) {
83		- $badge = desktop_mode_plugins_window_count_visible_updates();
	89	+ $badge = openstation_plugins_window_count_visible_updates();
84	90	}
85	91
86	92	// Determine the icon. Menu entries can set `$item[6]` to anything
87	93	// — a dashicon class, a remote URL, a data:URI, 'none', or 'div'
88	94	// — so normalize before we serialize it for the shell JS.
89		- $icon = desktop_mode_sanitize_dock_icon( $item[6] ?? '' );
	95	+ //
	96	+ // A blanked value falls back to whatever the row carried before
	97	+ // anything on `admin_menu` rewrote it, which is how plugin
	98	+ // artwork survives Jetpack's SVG-to-stylesheet move on
	99	+ // WordPress.com — see `openstation_snapshot_menu_icons()`.
	100	+ $raw_icon = (string) ( $item[6] ?? '' );
	101	+ if ( '' === $raw_icon || 'none' === $raw_icon || 'div' === $raw_icon ) {
	102	+ $snapshot = openstation_menu_icon_snapshot();
	103	+ if ( isset( $snapshot[ $item[2] ] ) ) {
	104	+ $raw_icon = $snapshot[ $item[2] ];
	105	+ }
	106	+ }
	107	+ $icon = openstation_sanitize_dock_icon( $raw_icon );
90	108
91	109	// Build the full URL for the menu item.
92	110	//
93	111	// `$parent_url` is the slug-derived URL (`admin.php?page=<slug>`
		@@ -95,11 +113,20 @@
95	113	// reference value the self-link strip below compares against.
96	114	// The effective `$url` we ship to the shell can be rewritten
97	115	// further down to the first visible submenu's URL — see the
98	116	// note after the loop.
99		- $parent_url = desktop_mode_menu_item_url( $item[2] );
100		- $url = $parent_url;
	117	+ $parent_url = openstation_menu_item_url( $item[2] );
	118	+ $parent_external = openstation_menu_item_is_external( $parent_url );
101	119
	120	+ // A menu owned by a regular plugin is allowed to keep off-site
	121	+ // children — a docs or support link under a plugin's own menu is
	122	+ // a normal thing to ship, and the flyout marks it as leaving the
	123	+ // site. Everything else drops them: a Core menu whose child was
	124	+ // repointed off-site (WordPress.com does this to Appearance →
	125	+ // Themes) gets its wp-admin original back instead, below.
	126	+ $plugin_file = openstation_resolve_menu_plugin_file( $item[2] );
	127	+ $allow_external_subs = null !== $plugin_file && ! $parent_external;
	128	+
102	129	// Build submenu items.
103	130	//
104	131	// WordPress auto-prepends a self-link entry to every parent
105	132	// menu's `$submenu[$slug]` (the first child shares the parent's
		@@ -106,19 +133,27 @@
106	133	// slug + URL — that's what `add_menu_page()` generates so the
107	134	// admin UI can render a clickable parent in the sidebar). For
108	135	// the shell's JS surface we strip this entry so:
109	136	//
110		- // - `submenu.length === 0` reliably means "no real children"
111		- // (the right-click submenu popover stays suppressed; the
112		- // in-window tab strip stays hidden).
113		- // - `submenu.length > 0` reliably means "has real child links"
114		- // — every entry points at a distinct URL.
	137	+ // - `submenu.length === 0` reliably means "no real children"
	138	+ // (the right-click submenu popover stays suppressed; the
	139	+ // in-window tab strip stays hidden).
	140	+ // - `submenu.length > 0` reliably means "has real child links"
	141	+ // — every entry points at a distinct URL.
115	142	//
116		- // Detection by URL (post-`desktop_mode_menu_item_url()` normalize)
	143	+ // Detection by URL (post-`openstation_menu_item_url()` normalize)
117	144	// rather than slug equality covers plugins that register a child
118	145	// at a different slug pointing at the parent's URL.
119		- $sub_items = array();
120		- $first_visible_sub_url = null;
	146	+ //
	147	+ // Two passes, because the second decision depends on the first:
	148	+ // a `hide-if-js` row is normally noise, but when it is the
	149	+ // wp-admin original of an off-site row we just dropped, it is
	150	+ // the route back to the page Core intended. The original takes
	151	+ // the replacement's place in the list, so the menu reads the way
	152	+ // it would have if nothing had swapped the row out.
	153	+ $rows = array();
	154	+ $restore_slots = array();
	155	+ $dropped_off_site = 0;
121	156	if ( ! empty( $submenu[ $item[2] ] ) ) {
122	157	foreach ( $submenu[ $item[2] ] as $sub_item ) {
123	158	if ( ! empty( $sub_item[1] ) && ! current_user_can( $sub_item[1] ) ) {
124	159	continue;
		@@ -128,42 +163,211 @@
128	163	// class; the semantics are "shown by default; hide only
129	164	// when `<body class=\"no-customize-support\">`". The
130	165	// Customizer is supported inside chromeless iframes, so
131	166	// these entries belong in the dock.
132		- $sub_url = desktop_mode_menu_item_url( $sub_item[2] );
133		- // Capture the first capability-passing submenu URL so
134		- // we can use it as the parent's effective URL below
135		- // (mirrors `wp-admin/menu-header.php`). Captured BEFORE
136		- // the self-link strip so plugins whose first submenu IS
137		- // the auto-prepended self-link land on the parent URL
138		- // (a no-op rewrite — preserves existing behavior).
139		- if ( null === $first_visible_sub_url ) {
140		- $first_visible_sub_url = $sub_url;
	167	+ $sub_url = openstation_menu_item_url( $sub_item[2] );
	168	+ $sub_external = openstation_menu_item_is_external( $sub_url );
	169	+
	170	+ if ( $sub_external && ! $allow_external_subs ) {
	171	+ ++$dropped_off_site;
	172	+ // Leave a slot behind, in case the wp-admin row this
	173	+ // entry displaced is still in the list.
	174	+ $dropped_title = openstation_menu_item_title( $sub_item[0] );
	175	+ if ( '' !== $dropped_title && ! isset( $restore_slots[ $dropped_title ] ) ) {
	176	+ $rows[] = array( 'restore' => $dropped_title );
	177	+ $restore_slots[ $dropped_title ] = count( $rows ) - 1;
	178	+ }
	179	+ continue;
141	180	}
142		- // Self-link strip — `$sub_url === $parent_url` covers
143		- // WP's auto-prepended entry AND any plugin-registered
144		- // alias that happens to land on the parent URL.
145		- if ( $sub_url === $parent_url ) {
146		- continue;
	181	+
	182	+ $rows[] = array(
	183	+ 'raw_title' => $sub_item[0],
	184	+ 'slug' => (string) $sub_item[2],
	185	+ 'url' => $sub_url,
	186	+ 'external' => $sub_external,
	187	+ 'hidden' => openstation_menu_item_is_hidden( $sub_item ),
	188	+ );
	189	+ }
	190	+ }
	191	+
	192	+ // Second pass. A hidden row moves into the slot its replacement
	193	+ // left; one whose replacement was the top-level slug itself
	194	+ // stays where it is (there is no slot — the menu row is not part
	195	+ // of this list). Every other hidden row, and every slot nothing
	196	+ // claimed, drops out.
	197	+ $restored = array();
	198	+ $keep = array_fill( 0, count( $rows ), true );
	199	+ foreach ( $rows as $i => $row ) {
	200	+ if ( isset( $row['restore'] ) || ! $row['hidden'] ) {
	201	+ continue;
	202	+ }
	203	+ $keep[ $i ] = false;
	204	+ $row_title = openstation_menu_item_title( $row['raw_title'] );
	205	+ if ( '' === $row_title || isset( $restored[ $row_title ] ) ) {
	206	+ continue;
	207	+ }
	208	+ if ( isset( $restore_slots[ $row_title ] ) ) {
	209	+ $rows[ $restore_slots[ $row_title ] ] = $row;
	210	+ $restored[ $row_title ] = true;
	211	+ } elseif ( $parent_external && $row_title === $title ) {
	212	+ // The menu's own row, hidden in place. WordPress builds
	213	+ // a parent's self-link by copying the menu row's first
	214	+ // four fields, so its label is the menu's label, which
	215	+ // is what makes the comparison hold.
	216	+ $keep[ $i ] = true;
	217	+ $restored[ $row_title ] = true;
	218	+ }
	219	+ }
	220	+
	221	+ // Last resort for a menu whose own slug points off-site: if
	222	+ // nothing on-site survived, take the first hidden on-site row
	223	+ // rather than lose the menu. The label comparison above is the
	224	+ // precise answer and covers the ordinary case, but it breaks the
	225	+ // moment a host relabels the menu row without relabelling the
	226	+ // self-link it already generated. Showing a row someone hid
	227	+ // beats dropping a working menu off the dock.
	228	+ if ( $parent_external ) {
	229	+ $has_on_site = false;
	230	+ foreach ( $rows as $i => $row ) {
	231	+ if ( ! isset( $row['restore'] ) && $keep[ $i ] && ! $row['external'] ) {
	232	+ $has_on_site = true;
	233	+ break;
147	234	}
148		- $sub_raw_title = preg_replace( '/<span[^>]*>.*?<\/span>/s', '', (string) $sub_item[0] );
149		- $sub_title = trim( wp_strip_all_tags( $sub_raw_title ) );
150		- // Skip entries with no resolvable title. Plugins (e.g.
151		- // WooCommerce's `wc-addons` Extensions row) register
152		- // `menu_title => null` to hide a row from classic admin's
153		- // left menu while keeping the page reachable. Without
154		- // this guard the dock renders an empty, label-less tab
155		- // that visually duplicates a sibling entry.
156		- if ( '' === $sub_title ) {
157		- continue;
	235	+ }
	236	+ if ( ! $has_on_site ) {
	237	+ foreach ( $rows as $i => $row ) {
	238	+ if ( isset( $row['restore'] ) || ! $row['hidden'] || $row['external'] ) {
	239	+ continue;
	240	+ }
	241	+ $keep[ $i ] = true;
	242	+ break;
158	243	}
159		- $sub_items[] = array(
160		- 'title' => $sub_title,
161		- 'url' => $sub_url,
162		- );
163	244	}
164	245	}
165	246
	247	+ $kept_rows = array();
	248	+ foreach ( $rows as $i => $row ) {
	249	+ if ( isset( $row['restore'] ) || ! $keep[ $i ] ) {
	250	+ continue;
	251	+ }
	252	+ $kept_rows[] = $row;
	253	+ }
	254	+ $rows = $kept_rows;
	255	+
	256	+ // When the top-level slug itself points off-site, the menu's
	257	+ // identity is now whichever child survived — adopt it before the
	258	+ // self-link strip runs, so a restored original collapses into
	259	+ // `selfLabel` instead of becoming a child that duplicates its
	260	+ // own parent.
	261	+ //
	262	+ // Identity travels with it. Everything below keys off the menu's
	263	+ // slug — whether it's a Core menu, whether a plugin owns it,
	264	+ // whether it opens more than one window, and which slug the
	265	+ // `openstation_dock_item` filter is told about. Left on the
	266	+ // off-site slug, a rescued Plugins tile reads as a plugin menu
	267	+ // owned by whoever registered the replacement, sorts to the far
	268	+ // end of the dock, and offers to deactivate them.
	269	+ $identity_slug = (string) $item[2];
	270	+ if ( $parent_external ) {
	271	+ foreach ( $rows as $row ) {
	272	+ if ( ! $row['external'] ) {
	273	+ $parent_url = $row['url'];
	274	+ $identity_slug = $row['slug'];
	275	+ break;
	276	+ }
	277	+ }
	278	+ }
	279	+
	280	+ // A menu that only ever pointed at its children, and whose
	281	+ // children we just took away. Checked only for menus the
	282	+ // off-site rule actually touched, so a menu registering its page
	283	+ // hook in some way we don't recognise is left exactly as it was.
	284	+ $parent_is_container = $dropped_off_site > 0
	285	+ && ! $parent_external
	286	+ && ! openstation_menu_slug_has_page( $item[2] );
	287	+
	288	+ $url = $parent_url;
	289	+ $sub_items = array();
	290	+ $first_visible_sub_url = null;
	291	+ $has_self_link = false;
	292	+ $self_label = '';
	293	+ foreach ( $rows as $row ) {
	294	+ $sub_url = $row['url'];
	295	+ if ( $parent_is_container && $sub_url === $parent_url ) {
	296	+ // A row pointing back at a menu with no page is a dead
	297	+ // end, not a way back — it can't name the menu and it
	298	+ // can't stand in for it.
	299	+ continue;
	300	+ }
	301	+ // Capture the first capability-passing submenu URL so
	302	+ // we can use it as the parent's effective URL below
	303	+ // (mirrors `wp-admin/menu-header.php`). Captured BEFORE
	304	+ // the self-link strip so plugins whose first submenu IS
	305	+ // the auto-prepended self-link land on the parent URL
	306	+ // (a no-op rewrite — preserves existing behavior). Never
	307	+ // an off-site child, which would take the whole tile with
	308	+ // it when the final external check runs.
	309	+ if ( null === $first_visible_sub_url && ! $row['external'] ) {
	310	+ $first_visible_sub_url = $sub_url;
	311	+ }
	312	+ // Self-link strip — `$sub_url === $parent_url` covers
	313	+ // WP's auto-prepended entry AND any plugin-registered
	314	+ // alias that happens to land on the parent URL.
	315	+ if ( $sub_url === $parent_url ) {
	316	+ $has_self_link = true;
	317	+ // Keep its LABEL, though. The stripped entry is a
	318	+ // real row in wp-admin's own menu ("All Posts",
	319	+ // "All Pages"), and the constellation flyout lists
	320	+ // it as the first thing the menu opens — a list of
	321	+ // a menu's pages that omits its main page reads as
	322	+ // a bug.
	323	+ //
	324	+ // Carried separately rather than left in `submenu`
	325	+ // because `submenu` has two other consumers that
	326	+ // need it to mean "distinct child links only": the
	327	+ // in-window tab strip, which would grow a duplicate
	328	+ // first tab, and the right-click popover, which is
	329	+ // suppressed on `length === 0`.
	330	+ //
	331	+ // First one only — a plugin can register several
	332	+ // aliases onto the parent URL, and the canonical
	333	+ // self-link is the one WordPress prepends.
	334	+ if ( '' === $self_label ) {
	335	+ $self_label = openstation_menu_item_title( $row['raw_title'] );
	336	+ }
	337	+ continue;
	338	+ }
	339	+ // Skip entries with no resolvable title. Plugins (e.g.
	340	+ // WooCommerce's `wc-addons` Extensions row) register
	341	+ // `menu_title => null` to hide a row from classic admin's
	342	+ // left menu while keeping the page reachable. Without
	343	+ // this guard the dock renders an empty, label-less tab
	344	+ // that visually duplicates a sibling entry.
	345	+ $sub_title = openstation_menu_item_title( $row['raw_title'] );
	346	+ if ( '' === $sub_title ) {
	347	+ continue;
	348	+ }
	349	+ $sub_entry = array(
	350	+ 'title' => $sub_title,
	351	+ 'url' => $sub_url,
	352	+ // The registered slug, kept for the window-tab merge
	353	+ // below and stripped again before the payload ships.
	354	+ 'slug' => (string) $row['slug'],
	355	+ );
	356	+ if ( $row['external'] ) {
	357	+ // Consumers that route a URL into a window skip these;
	358	+ // the ones that can hand a link to the browser mark
	359	+ // them as leaving the site.
	360	+ //
	361	+ // `offSite` rather than `external`: the window's tab
	362	+ // strip already calls plugin-opened sub-iframe tabs
	363	+ // "external" (`data-kind="external"`), and that is a
	364	+ // different thing entirely.
	365	+ $sub_entry['offSite'] = true;
	366	+ }
	367	+ $sub_items[] = $sub_entry;
	368	+ }
	369	+
166	370	// Mirror `wp-admin/menu-header.php`: when a parent menu has any
167	371	// visible submenu, classic admin rewrites the parent's
168	372	// clickable URL to the first submenu's URL. Plugins like
169	373	// WooCommerce rely on this — their top-level slug
		@@ -171,27 +375,96 @@
171	375	// directly. The real landing page is the first submenu
172	376	// (`?page=wc-admin` for WC). Without this rewrite the dock
173	377	// icon points users at a broken URL that classic admin would
174	378	// never have linked to.
175		- if ( null !== $first_visible_sub_url ) {
	379	+ //
	380	+ // A menu that registered a self-link has a working page of its
	381	+ // own and keeps it, wherever in the list that link sits. Only
	382	+ // the WooCommerce shape — no self-link at all — needs a child to
	383	+ // stand in. Position matters here because a restored wp-admin
	384	+ // row inherits the slot its off-site replacement held, which on
	385	+ // WordPress.com puts `plugin-install.php` first under Plugins.
	386	+ if ( null !== $first_visible_sub_url && ! $has_self_link ) {
176	387	$url = $first_visible_sub_url;
177	388	}
178	389
	390	+ // Nothing on this menu resolves to a page we can open. Hosts
	391	+ // that link their own control panel from the admin menu
	392	+ // (WordPress.com's My Home, Theme Showcase, Hosting) land here,
	393	+ // and so does a Core menu whose slug was repointed off-site with
	394	+ // no wp-admin child left to fall back to.
	395	+ if ( openstation_menu_item_is_external( $url ) ) {
	396	+ continue;
	397	+ }
	398	+
	399	+ // A container menu with nothing left to stand in for it. Its
	400	+ // URL resolves to core's "Cannot load <slug>." page, which is a
	401	+ // worse tile than no tile.
	402	+ if ( $parent_is_container && $url === $parent_url ) {
	403	+ continue;
	404	+ }
	405	+
	406	+ // A native window in charge of this menu owns its rows too:
	407	+ // whatever it offers as a tab, the dock offers as a row, same
	408	+ // labels and same order, each one tagged with the tab it
	409	+ // opens. The first tab IS the menu's own page, so it becomes
	410	+ // the self-label rather than a second row for the tile's own
	411	+ // destination. See `App::menu()`.
	412	+ $window_tabs = openstation_app_menu_tabs( $identity_slug );
	413	+ if ( $window_tabs ) {
	414	+ $self_label = $window_tabs[0]['label'];
	415	+ $claimed = array();
	416	+ foreach ( $window_tabs as $tab ) {
	417	+ if ( '' !== $tab['page'] ) {
	418	+ $claimed[] = $tab['page'];
	419	+ }
	420	+ }
	421	+ // A page this window has no tab for is still a page: a
	422	+ // plugin's screen registered under this menu, a taxonomy
	423	+ // someone added. Dropping those would make them
	424	+ // unreachable from the dock, so they follow the window's
	425	+ // own rows rather than being replaced by them.
	426	+ $kept = array();
	427	+ foreach ( $sub_items as $sub_entry ) {
	428	+ if ( ! in_array( $sub_entry['slug'], $claimed, true ) ) {
	429	+ $kept[] = $sub_entry;
	430	+ }
	431	+ }
	432	+ $sub_items = array();
	433	+ foreach ( array_slice( $window_tabs, 1 ) as $tab ) {
	434	+ $sub_items[] = array(
	435	+ 'title' => $tab['label'],
	436	+ 'url' => add_query_arg( 'os_tab', $tab['id'], $url ),
	437	+ );
	438	+ }
	439	+ $sub_items = array_merge( $sub_items, $kept );
	440	+ }
	441	+ foreach ( $sub_items as $i => $sub_entry ) {
	442	+ unset( $sub_items[ $i ]['slug'] );
	443	+ }
	444	+
179	445	$dock_item = array(
180		- 'id' => sanitize_key( $item[5] ?? $item[2] ),
181		- 'title' => $title,
182		- 'icon' => $icon,
183		- 'url' => $url,
184		- 'badge' => $badge,
185		- 'submenu' => $sub_items,
186		- 'multi' => desktop_mode_dock_item_is_multi( $item[2] ),
187		- 'placement' => desktop_mode_dock_placement( $item[2] ),
188		- 'isCore' => desktop_mode_is_core_menu_slug( $item[2] ),
189		- 'pluginFile' => desktop_mode_resolve_menu_plugin_file( $item[2] ),
	446	+ 'id' => sanitize_key( $item[5] ?? $item[2] ),
	447	+ 'title' => $title,
	448	+ 'icon' => $icon,
	449	+ 'url' => $url,
	450	+ 'badge' => $badge,
	451	+ 'submenu' => $sub_items,
	452	+ // Label of the stripped self-link ("All Posts"), for
	453	+ // surfaces that list a menu's pages and want its main page
	454	+ // named the way wp-admin names it. Empty when the menu had
	455	+ // no self-link to strip.
	456	+ 'selfLabel' => $self_label,
	457	+ 'multi' => openstation_dock_item_is_multi( $identity_slug ),
	458	+ 'placement' => openstation_dock_placement( $identity_slug ),
	459	+ 'isCore' => openstation_is_core_menu_slug( $identity_slug ),
	460	+ 'pluginFile' => $identity_slug === (string) $item[2]
	461	+ ? $plugin_file
	462	+ : openstation_resolve_menu_plugin_file( $identity_slug ),
190	463	'pluginName' => null,
191	464	);
192	465	if ( $dock_item['pluginFile'] ) {
193		- $dock_item['pluginName'] = desktop_mode_plugin_display_name( $dock_item['pluginFile'] );
	466	+ $dock_item['pluginName'] = openstation_plugin_display_name( $dock_item['pluginFile'] );
194	467	}
195	468
196	469	/**
197	470	* Filters a single dock item's data.
		@@ -198,9 +471,9 @@
198	471	*
199	472	* @param array $dock_item The dock item data.
200	473	* @param string $menu_slug The menu slug.
201	474	*/
202		- $dock_item = apply_filters( 'desktop_mode_dock_item', $dock_item, $item[2] );
	475	+ $dock_item = apply_filters( 'openstation_dock_item', $dock_item, $identity_slug );
203	476
204	477	$items[] = $dock_item;
205	478	}
206	479
		@@ -208,12 +481,181 @@
208	481	* Filters the dock items before they are passed to JavaScript.
209	482	*
210	483	* @param array[] $items Array of dock item arrays.
211	484	*/
212		- return apply_filters( 'desktop_mode_dock_items', $items );
	485	+ return apply_filters( 'openstation_dock_items', $items );
213	486	}
214	487
215	488	/**
	489	+ * Whether a resolved menu URL points at a host other than this site's.
	490	+ *
	491	+ * OpenStation opens admin pages inside iframes, and an off-site URL
	492	+ * cannot load in one — the remote origin's `X-Frame-Options` /
	493	+ * `frame-ancestors` header refuses it. Hosts that extend the admin
	494	+ * menu with links to their own control panel (WordPress.com registers
	495	+ * My Home, Theme Showcase, Hosting and friends as `wordpress.com`
	496	+ * URLs) would therefore fill the dock with tiles that can only ever
	497	+ * escape to a browser tab, which breaks the shell's navigation model.
	498	+ * Those entries are dropped from the payload instead.
	499	+ *
	500	+ * The menu's own admin (`openstation_menu_admin_url()`), `admin_url()`
	501	+ * and `home_url()` hosts all count as ours: a site can run its admin on
	502	+ * a different domain than its front end, and the network admin lives on
	503	+ * the network's own.
	504	+ *
	505	+ * @param string $url Absolute URL, as returned by `openstation_menu_item_url()`.
	506	+ * @return bool True when the URL is off-site.
	507	+ */
	508	+function openstation_menu_item_is_external( $url ) {
	509	+ $host = wp_parse_url( (string) $url, PHP_URL_HOST );
	510	+ $external = false;
	511	+
	512	+ if ( $host ) {
	513	+ $ours = array();
	514	+ foreach ( array( openstation_menu_admin_url(), admin_url(), home_url() ) as $known ) {
	515	+ $known_host = wp_parse_url( $known, PHP_URL_HOST );
	516	+ if ( $known_host ) {
	517	+ $ours[] = strtolower( $known_host );
	518	+ }
	519	+ }
	520	+ $external = ! in_array( strtolower( $host ), $ours, true );
	521	+ }
	522	+
	523	+ /**
	524	+ * Filters whether an admin-menu URL counts as off-site.
	525	+ *
	526	+ * @param bool $external Whether the URL points off-site.
	527	+ * @param string $url The resolved menu URL.
	528	+ */
	529	+ return (bool) apply_filters( 'openstation_menu_item_is_external', $external, $url );
	530	+}
	531	+
	532	+/**
	533	+ * Whether a `$menu` / `$submenu` row carries the `hide-if-js` class.
	534	+ *
	535	+ * Core never sets it on a menu row, so it reads as "some other code
	536	+ * took this entry out of the sidebar". Jetpack's admin-menu
	537	+ * customisation on WordPress.com uses it heavily: rather than replace
	538	+ * a Core entry with its wordpress.com counterpart, it marks the
	539	+ * original `hide-if-js` and appends a duplicate pointing at Calypso.
	540	+ * Honouring the class is what keeps those pairs from rendering twice
	541	+ * in the dock.
	542	+ *
	543	+ * @param array $item A `$menu` or `$submenu` row.
	544	+ * @return bool True when the row is hidden from the classic sidebar.
	545	+ */
	546	+function openstation_menu_item_is_hidden( $item ) {
	547	+ return ! empty( $item[4] ) && false !== strpos( (string) $item[4], 'hide-if-js' );
	548	+}
	549	+
	550	+/**
	551	+ * Whether a top-level menu slug has a page of its own behind it.
	552	+ *
	553	+ * `add_menu_page()` accepts a `null` callback, which registers a menu
	554	+ * that is nothing but a container for its children — WordPress links
	555	+ * such a parent to its first submenu and `admin.php` refuses the slug
	556	+ * directly with "Cannot load <slug>." WordPress.com's Upgrades menu is
	557	+ * one: `paid-upgrades.php` has no callback and no self-link, and every
	558	+ * child is a wordpress.com URL. Drop the children and the tile is left
	559	+ * pointing at core's error page.
	560	+ *
	561	+ * Two ways a slug earns a page: it names a real file under `wp-admin/`,
	562	+ * or something is listening on its page hook — the same `has_action()`
	563	+ * test `get_plugin_page_hook()` makes before `admin.php` gives up.
	564	+ * Anything we can't answer counts as a page, so an unusual registration
	565	+ * costs a menu nothing.
	566	+ *
	567	+ * @param string $slug The menu slug from `$menu[$i][2]`.
	568	+ * @return bool False only when the slug is provably a container.
	569	+ */
	570	+function openstation_menu_slug_has_page( $slug ) {
	571	+ if ( openstation_is_admin_file_slug( $slug ) ) {
	572	+ return true;
	573	+ }
	574	+
	575	+ if ( ! function_exists( 'get_plugin_page_hookname' ) ) {
	576	+ return true;
	577	+ }
	578	+
	579	+ $hookname = get_plugin_page_hookname( $slug, '' );
	580	+ if ( empty( $hookname ) ) {
	581	+ return true;
	582	+ }
	583	+
	584	+ return has_action( $hookname );
	585	+}
	586	+
	587	+/**
	588	+ * Lazy accessor for the pre-rewrite menu icon snapshot: `slug → icon`.
	589	+ *
	590	+ * Populated by {@see openstation_snapshot_menu_icons()}.
	591	+ *
	592	+ * @return array<string,string>
	593	+ */
	594	+function &openstation_menu_icon_snapshot() {
	595	+ static $map = null;
	596	+ if ( null === $map ) {
	597	+ $map = array();
	598	+ }
	599	+ return $map;
	600	+}
	601	+
	602	+/**
	603	+ * Record the first real icon each menu row is seen wearing.
	604	+ *
	605	+ * A menu row's icon is not final when it is registered. Anything on
	606	+ * `admin_menu` can rewrite `$menu[ $i ][6]`, and the rewrite that hurts
	607	+ * is to `'none'` — the row keeps its picture in the sidebar, painted
	608	+ * from a stylesheet instead, and the menu array stops carrying it. The
	609	+ * dock reads the array, so those menus arrived wearing a generic gear.
	610	+ * Jetpack's `override_svg_icons()` does this to every SVG-data-URI icon
	611	+ * on WordPress.com, which is where it was found, but nothing about the
	612	+ * move is specific to that host.
	613	+ *
	614	+ * Rather than sit at one priority chosen to undercut one known rewriter,
	615	+ * sample repeatedly and **never overwrite**: the map keeps the earliest
	616	+ * real icon each slug had, whenever it appeared and whoever blanked it
	617	+ * afterwards. Write-once is safe because the map is only ever consulted
	618	+ * as a fallback — a menu that genuinely changes its icon still ships the
	619	+ * live value.
	620	+ *
	621	+ * A slug that had no real icon at any sample point is simply absent, and
	622	+ * the caller lands on the generic fallback it would have had anyway.
	623	+ */
	624	+function openstation_snapshot_menu_icons() {
	625	+ global $menu;
	626	+
	627	+ if ( ! is_array( $menu ) ) {
	628	+ return;
	629	+ }
	630	+
	631	+ $map = &openstation_menu_icon_snapshot();
	632	+
	633	+ foreach ( $menu as $item ) {
	634	+ if ( empty( $item[2] ) || empty( $item[6] ) ) {
	635	+ continue;
	636	+ }
	637	+ $slug = (string) $item[2];
	638	+ if ( isset( $map[ $slug ] ) ) {
	639	+ continue;
	640	+ }
	641	+ $icon = (string) $item[6];
	642	+ if ( 'none' === $icon || 'div' === $icon ) {
	643	+ continue;
	644	+ }
	645	+ $map[ $slug ] = $icon;
	646	+ }
	647	+}
	648	+// Spread across the hook rather than parked just below any one
	649	+// rewriter: registrations and rewrites both happen at arbitrary
	650	+// priorities, and only a sample taken before a given rewrite can see
	651	+// what it overwrote.
	652	+foreach ( array( 11, 100, 1000, 99998, PHP_INT_MAX ) as $openstation_icon_snapshot_priority ) {
	653	+ add_action( 'admin_menu', 'openstation_snapshot_menu_icons', $openstation_icon_snapshot_priority );
	654	+}
	655	+unset( $openstation_icon_snapshot_priority );
	656	+
	657	+/**
216	658	* Sanitizes a dock icon value for safe injection into the shell JS.
217	659	*
218	660	* Menu items can set their icon to one of:
219	661	*
		@@ -243,9 +685,9 @@
243	685	*
244	686	* @param mixed $icon Raw icon value from the menu registration.
245	687	* @return string Sanitized icon string.
246	688	*/
247		-function desktop_mode_sanitize_dock_icon( $icon ) {
	689	+function openstation_sanitize_dock_icon( $icon ) {
248	690	$fallback = 'dashicons-admin-generic';
249	691	if ( ! is_string( $icon ) || '' === $icon ) {
250	692	return $fallback;
251	693	}
		@@ -304,9 +746,9 @@
304	746	* have a single logical state — opening two makes no sense.
305	747	*
306	748	* The default rule matches the base filename of the menu slug against a
307	749	* known list. Plugin authors can override via the
308		- * `desktop_mode_dock_item_multi` filter to mark any custom page as multi
	750	+ * `openstation_dock_item_multi` filter to mark any custom page as multi
309	751	* (or force a stock list page into singleton mode).
310	752	*
311	753	* @param string $menu_slug The raw menu slug (e.g. `edit.php`, `upload.php`,
312	754	* or `my-plugin-page`). Query strings are preserved
		@@ -312,9 +754,9 @@
312	754	* or `my-plugin-page`). Query strings are preserved
313	755	* so `edit.php?post_type=page` resolves correctly.
314	756	* @return bool True if this page supports multiple simultaneous windows.
315	757	*/
316		-function desktop_mode_dock_item_is_multi( $menu_slug ) {
	758	+function openstation_dock_item_is_multi( $menu_slug ) {
317	759	// Multi-capable admin files. Match by the base file regardless of
318	760	// any query string (post_type, taxonomy, page, paged, etc.) so every
319	761	// CPT and every taxonomy inherits the same rule as their parent.
320	762	$multi_files = array(
		@@ -324,23 +766,24 @@
324	766	'users.php',
325	767	'edit-comments.php',
326	768	);
327	769
328		- $base = strtok( (string) $menu_slug, '?' );
	770	+ $base = strtok( (string) $menu_slug, '?' );
329	771	$multi = in_array( $base, $multi_files, true );
330	772
331	773	/**
332	774	* Filters whether a dock item supports multiple open windows.
333	775	*
334		- * Return true to let the user open more than one window of this page.
335		- * A "+" affordance appears on the dock icon and a "Open another" action
336		- * becomes available in the window's title-bar menu. Singletons (false)
337		- * always focus the existing window when re-opened.
	776	+ * Return true to advertise this page as multi-capable: an instance
	777	+ * rail appears under the dock icon and an "Open another" action
	778	+ * becomes available in the window's title-bar menu. It does not gate
	779	+ * the submenu, which opens a window of its own on every pick either
	780	+ * way; a tile click focuses the menu's open window.
338	781	*
339	782	* @param bool $multi Whether this page is multi-capable.
340	783	* @param string $menu_slug The menu slug (e.g. `edit.php?post_type=page`).
341	784	*/
342		- return (bool) apply_filters( 'desktop_mode_dock_item_multi', $multi, $menu_slug );
	785	+ return (bool) apply_filters( 'openstation_dock_item_multi', $multi, $menu_slug );
343	786	}
344	787
345	788	/**
346	789	* Returns true when `$menu_slug` maps to a first-party WordPress
		@@ -364,13 +807,13 @@
364	807	* with custom top-level files can still opt in via the filter
365	808	* below).
366	809	*
367	810	* Plugins + site admins can override any answer via
368		- * `desktop_mode_dock_placement`:
	811	+ * `openstation_dock_placement`:
369	812	*
370	813	* ```php
371	814	* // Keep Jetpack on the left dock:
372		- * add_filter( 'desktop_mode_dock_placement', function ( $placement, $slug ) {
	815	+ * add_filter( 'openstation_dock_placement', function ( $placement, $slug ) {
373	816	* return 'jetpack' === $slug ? 'dock' : $placement;
374	817	* }, 10, 2 );
375	818	* ```
376	819	*
		@@ -376,9 +819,9 @@
376	819	*
377	820	* @param string $menu_slug Menu item slug (e.g. `edit.php`, `edit.php?post_type=foo`, `woocommerce`).
378	821	* @return bool True when the slug is a core admin page.
379	822	*/
380		-function desktop_mode_is_core_menu_slug( $menu_slug ) {
	823	+function openstation_is_core_menu_slug( $menu_slug ) {
381	824	$slug = (string) $menu_slug;
382	825	$base = strtok( $slug, '?' );
383	826
384	827	// Known top-level core admin files. Stable across WP versions —
		@@ -419,8 +862,19 @@
419	862	'link-manager.php', // Link manager (legacy)
420	863	'update-core.php', // Dashboard > Updates
421	864	);
422	865
	866	+ // The two top-level network menus the site admin has no filename
	867	+ // for: without them, Sites and Settings sat in the apps zone while
	868	+ // Dashboard, Users, Themes and Plugins — whose filenames the site
	869	+ // admin shares — grouped correctly. Gated on the context, since
	870	+ // `settings.php` is plausible enough as a plugin's own top-level
	871	+ // slug that claiming it everywhere would misfile it.
	872	+ if ( is_network_admin() ) {
	873	+ $core_files[] = 'sites.php';
	874	+ $core_files[] = 'settings.php';
	875	+ }
	876	+
423	877	return in_array( $base, $core_files, true );
424	878	}
425	879
426	880	/**
		@@ -429,9 +883,9 @@
429	883	* registered for the menu's page hook.
430	884	*
431	885	* Returns the plugin's main file path (relative to `WP_PLUGIN_DIR`) when
432	886	* the menu was registered by a regular plugin, `null` otherwise. Core
433		- * menus, mu-plugins, drop-ins, theme-registered menus, and Desktop Mode
	887	+ * menus, mu-plugins, drop-ins, theme-registered menus, and OpenStation
434	888	* itself all return `null` — none of these are deactivatable through the
435	889	* `wp/v2/plugins` REST route, so the dock right-click menu should not
436	890	* offer a deactivate action for them.
437	891	*
		@@ -445,9 +899,9 @@
445	899	* lives here.
446	900	* 3. Reflect each callback to find its declaring file. Match the file
447	901	* path against `WP_PLUGIN_DIR/<folder>/…` and use `<folder>` to look
448	902	* up an entry in `get_plugins()`. Return the matching `<folder>/<file>.php`.
449		- * 4. Exclude Desktop Mode itself — deactivating from inside the shell
	903	+ * 4. Exclude OpenStation itself — deactivating from inside the shell
450	904	* is handled by the plugins-window's self-deactivate path.
451	905	*
452	906	* @param string $menu_slug The menu slug from `$menu[$i][2]` (e.g. `woocommerce`,
453	907	* `admin.php?page=jetpack`, `edit.php?post_type=foo`).
		@@ -453,9 +907,9 @@
453	907	* `admin.php?page=jetpack`, `edit.php?post_type=foo`).
454	908	* @return string|null Plugin file path relative to `WP_PLUGIN_DIR`, or null
455	909	* when the slug isn't owned by a deactivatable plugin.
456	910	*/
457		-function desktop_mode_resolve_menu_plugin_file( $menu_slug ) {
	911	+function openstation_resolve_menu_plugin_file( $menu_slug ) {
458	912	$slug = (string) $menu_slug;
459	913
460	914	// `get_plugin_page_hookname` + `get_plugins` come from
461	915	// `wp-admin/includes/plugin.php`, which Core loads itself on
		@@ -466,12 +920,12 @@
466	920	if ( ! function_exists( 'get_plugin_page_hookname' ) || ! function_exists( 'get_plugins' ) ) {
467	921	return null;
468	922	}
469	923
470		- $self_basename = defined( 'DESKTOP_MODE_FILE' ) ? plugin_basename( DESKTOP_MODE_FILE ) : '';
	924	+ $self_basename = defined( 'OPENSTATION_FILE' ) ? plugin_basename( OPENSTATION_FILE ) : '';
471	925
472	926	// Strategy 1 — registration-time attribution. The admin_menu hook
473		- // wrapper (see `desktop_mode_install_menu_attribution_tracker`) snapshots
	927	+ // wrapper (see `openstation_install_menu_attribution_tracker`) snapshots
474	928	// `$menu`/`$submenu` around every admin_menu callback and records
475	929	// "this plugin file added this slug". This is the authoritative
476	930	// source — it captures menus whose page hook isn't predictable from
477	931	// the slug (e.g. WC's `wc-admin&path=/marketing`) and handles
		@@ -476,9 +930,9 @@
476	930	// source — it captures menus whose page hook isn't predictable from
477	931	// the slug (e.g. WC's `wc-admin&path=/marketing`) and handles
478	932	// callbacks that simply forward to a shared renderer (which
479	933	// reflection would mis-attribute).
480		- $map = desktop_mode_menu_attribution_map();
	934	+ $map = openstation_menu_attribution_map();
481	935	if ( isset( $map[ $slug ] ) ) {
482	936	$plugin_file = $map[ $slug ];
483	937	if ( $self_basename && $plugin_file === $self_basename ) {
484	938	return null;
		@@ -490,9 +944,9 @@
490	944	// / `edit-tags.php` handle the render, so the page hook would never
491	945	// point at the registering plugin. We caught the plugin at
492	946	// `register_post_type()` / `register_taxonomy()` time via
493	947	// `debug_backtrace()`.
494		- $tracked = desktop_mode_lookup_taxonomy_or_post_type_plugin_file( $slug );
	948	+ $tracked = openstation_lookup_taxonomy_or_post_type_plugin_file( $slug );
495	949	if ( null !== $tracked ) {
496	950	if ( $self_basename && $tracked === $self_basename ) {
497	951	return null;
498	952	}
		@@ -502,12 +956,12 @@
502	956	$base = strtok( $slug, '?' );
503	957
504	958	// Cheap reject: literal core PHP files with no `?page=` parameter
505	959	// (the universal "a plugin registered an admin route" signal). We
506		- // can't reuse `desktop_mode_is_core_menu_slug()` here — that
	960	+ // can't reuse `openstation_is_core_menu_slug()` here — that
507	961	// classifier strtok's the query string and treats `admin.php?page=foo`
508	962	// as core, which would hide every plugin-registered top-level tile.
509		- if ( desktop_mode_is_pure_core_file( $base ) && false === strpos( $slug, '?page=' ) ) {
	963	+ if ( openstation_is_pure_core_file( $base ) && false === strpos( $slug, '?page=' ) ) {
510	964	return null;
511	965	}
512	966
513	967	// Strategy 3 — page-hook reflection fallback. The earlier strategies
		@@ -523,9 +977,9 @@
523	977
524	978	$hook = $wp_filter[ $hookname ];
525	979	foreach ( $hook->callbacks as $cbs ) {
526	980	foreach ( $cbs as $cb ) {
527		- $plugin_file = desktop_mode_plugin_file_for_callback( $cb['function'] ?? null );
	981	+ $plugin_file = openstation_plugin_file_for_callback( $cb['function'] ?? null );
528	982	if ( ! $plugin_file ) {
529	983	continue;
530	984	}
531	985	if ( $self_basename && $plugin_file === $self_basename ) {
		@@ -546,11 +1000,12 @@
546	1000	*
547	1001	* @param string $plugin_file Plugin file relative to `WP_PLUGIN_DIR`.
548	1002	* @return string Display name.
549	1003	*/
550		-function desktop_mode_plugin_display_name( $plugin_file ) {
	1004	+function openstation_plugin_display_name( $plugin_file ) {
551	1005	if ( ! function_exists( 'get_plugins' ) ) {
552		- return strtok( $plugin_file, '/' ) ?: $plugin_file;
	1006	+ $dir = strtok( $plugin_file, '/' );
	1007	+ return $dir ? $dir : $plugin_file;
553	1008	}
554	1009	$installed = get_plugins();
555	1010	if ( isset( $installed[ $plugin_file ]['Name'] ) && '' !== $installed[ $plugin_file ]['Name'] ) {
556	1011	return (string) $installed[ $plugin_file ]['Name'];
		@@ -567,14 +1022,14 @@
567	1022	*
568	1023	* @param string $file Absolute filesystem path.
569	1024	* @return string|null Plugin file (`<folder>/<file>.php`) or null.
570	1025	*/
571		-function desktop_mode_plugin_file_for_path( $file ) {
	1026	+function openstation_plugin_file_for_path( $file ) {
572	1027	if ( ! is_string( $file ) || '' === $file ) {
573	1028	return null;
574	1029	}
575	1030	$plugins_dir = wp_normalize_path( WP_PLUGIN_DIR );
576		- $norm = wp_normalize_path( $file );
	1031	+ $norm = openstation_plugin_link_path( wp_normalize_path( $file ) );
577	1032	if ( 0 !== strpos( $norm, $plugins_dir . '/' ) ) {
578	1033	return null;
579	1034	}
580	1035	if ( ! function_exists( 'get_plugins' ) ) {
		@@ -598,16 +1053,16 @@
598	1053
599	1054	/**
600	1055	* Convenience wrapper: reflect on a callback to find its declaring
601	1056	* file, then map that file to an active plugin via
602		- * {@see desktop_mode_plugin_file_for_path()}.
	1057	+ * {@see openstation_plugin_file_for_path()}.
603	1058	*
604	1059	* @param mixed $callback A WP-style callback.
605	1060	* @return string|null Plugin file or null.
606	1061	*/
607		-function desktop_mode_plugin_file_for_callback( $callback ) {
608		- $file = desktop_mode_callback_source_file( $callback );
609		- return $file ? desktop_mode_plugin_file_for_path( $file ) : null;
	1062	+function openstation_plugin_file_for_callback( $callback ) {
	1063	+ $file = openstation_callback_source_file( $callback );
	1064	+ return $file ? openstation_plugin_file_for_path( $file ) : null;
610	1065	}
611	1066
612	1067	/**
613	1068	* Lazy accessor + lazy initializer for the registration-time menu
		@@ -612,13 +1067,13 @@
612	1067	/**
613	1068	* Lazy accessor + lazy initializer for the registration-time menu
614	1069	* attribution map: `slug → plugin_file`. The map is populated by the
615	1070	* wrapped admin_menu callbacks installed by
616		- * {@see desktop_mode_install_menu_attribution_tracker()}.
	1071	+ * {@see openstation_install_menu_attribution_tracker()}.
617	1072	*
618	1073	* @return array<string,string>
619	1074	*/
620		-function &desktop_mode_menu_attribution_map() {
	1075	+function &openstation_menu_attribution_map() {
621	1076	static $map = null;
622	1077	if ( null === $map ) {
623	1078	$map = array();
624	1079	}
		@@ -644,9 +1099,9 @@
644	1099	*
645	1100	* This is the source of truth for plugin → menu ownership because it
646	1101	* captures menus regardless of slug shape, hook name predictability,
647	1102	* or whether the plugin shares a render callback. Reflection on the
648		- * page hook (in `desktop_mode_resolve_menu_plugin_file`) is now a
	1103	+ * page hook (in `openstation_resolve_menu_plugin_file`) is now a
649	1104	* fallback for the rare cases where the tracker wasn't able to install
650	1105	* in time.
651	1106	*
652	1107	* Idempotent — runs at most once per request via a static `$installed`
		@@ -653,9 +1108,9 @@
653	1108	* flag.
654	1109	*
655	1110	* @return void
656	1111	*/
657		-function desktop_mode_install_menu_attribution_tracker() {
	1112	+function openstation_install_menu_attribution_tracker() {
658	1113	static $installed = false;
659	1114	if ( $installed ) {
660	1115	return;
661	1116	}
		@@ -669,9 +1124,9 @@
669	1124
670	1125	foreach ( $hook->callbacks as $priority => $cbs ) {
671	1126	foreach ( $cbs as $id => $cb ) {
672	1127	$orig = $cb['function'] ?? null;
673		- $plugin_file = desktop_mode_plugin_file_for_callback( $orig );
	1128	+ $plugin_file = openstation_plugin_file_for_callback( $orig );
674	1129	if ( ! $plugin_file || ! is_callable( $orig ) ) {
675	1130	continue;
676	1131	}
677	1132	$accepted_args = (int) ( $cb['accepted_args'] ?? 1 );
		@@ -703,9 +1158,9 @@
703	1158
704	1159	$args = func_get_args();
705	1160	$return = call_user_func_array( $orig, $args );
706	1161
707		- $map = &desktop_mode_menu_attribution_map();
	1162	+ $map = &openstation_menu_attribution_map();
708	1163
709	1164	if ( is_array( $menu ) ) {
710	1165	foreach ( $menu as $entry ) {
711	1166	if ( ! isset( $entry[2] ) ) {
		@@ -761,14 +1216,14 @@
761	1216	}
762	1217	}
763	1218	}
764	1219
765		-add_action( '_admin_menu', 'desktop_mode_install_menu_attribution_tracker', -PHP_INT_MAX );
766		-add_action( '_network_admin_menu', 'desktop_mode_install_menu_attribution_tracker', -PHP_INT_MAX );
767		-add_action( '_user_admin_menu', 'desktop_mode_install_menu_attribution_tracker', -PHP_INT_MAX );
	1220	+add_action( '_admin_menu', 'openstation_install_menu_attribution_tracker', -PHP_INT_MAX );
	1221	+add_action( '_network_admin_menu', 'openstation_install_menu_attribution_tracker', -PHP_INT_MAX );
	1222	+add_action( '_user_admin_menu', 'openstation_install_menu_attribution_tracker', -PHP_INT_MAX );
768	1223
769	1224	/**
770		- * The subset of `desktop_mode_is_core_menu_slug`'s "core files" that's
	1225	+ * The subset of `openstation_is_core_menu_slug`'s "core files" that's
771	1226	* actually owned by Core regardless of any query string — this is what
772	1227	* we use inside the plugin-file resolver to reject Posts / Pages / etc.
773	1228	* without rejecting `admin.php?page=…` (a universal plugin signal that
774	1229	* the public is_core classifier also incorrectly treats as core for
		@@ -779,9 +1234,9 @@
779	1234	*
780	1235	* @param string $base Slug with query string already stripped.
781	1236	* @return bool True when the base filename is a Core admin handler.
782	1237	*/
783		-function desktop_mode_is_pure_core_file( $base ) {
	1238	+function openstation_is_pure_core_file( $base ) {
784	1239	$core_files = array(
785	1240	'index.php',
786	1241	'edit-comments.php',
787	1242	'upload.php',
		@@ -831,9 +1286,9 @@
831	1286	*
832	1287	* @param string $slug Menu slug.
833	1288	* @return string|null Plugin file or null.
834	1289	*/
835		-function desktop_mode_lookup_taxonomy_or_post_type_plugin_file( $slug ) {
	1290	+function openstation_lookup_taxonomy_or_post_type_plugin_file( $slug ) {
836	1291	if ( false !== strpos( $slug, 'edit.php?' ) && false !== strpos( $slug, 'post_type=' ) ) {
837	1292	$qs = wp_parse_url( 'http://x/' . ltrim( $slug, '/' ), PHP_URL_QUERY );
838	1293	parse_str( (string) $qs, $args );
839	1294	$pt = isset( $args['post_type'] ) ? (string) $args['post_type'] : '';
		@@ -839,10 +1294,10 @@
839	1294	$pt = isset( $args['post_type'] ) ? (string) $args['post_type'] : '';
840	1295	if ( '' === $pt ) {
841	1296	return null;
842	1297	}
843		- $map = desktop_mode_get_typed_plugin_map();
844		- return $map['post_type'][ $pt ] ?? null;
	1298	+ $file = openstation_type_registrant_file( $pt, 'post_type' );
	1299	+ return null === $file ? null : openstation_plugin_file_for_path( $file );
845	1300	}
846	1301	if ( false !== strpos( $slug, 'edit-tags.php?' ) && false !== strpos( $slug, 'taxonomy=' ) ) {
847	1302	$qs = wp_parse_url( 'http://x/' . ltrim( $slug, '/' ), PHP_URL_QUERY );
848	1303	parse_str( (string) $qs, $args );
		@@ -849,25 +1304,36 @@
849	1304	$tx = isset( $args['taxonomy'] ) ? (string) $args['taxonomy'] : '';
850	1305	if ( '' === $tx ) {
851	1306	return null;
852	1307	}
853		- $map = desktop_mode_get_typed_plugin_map();
854		- return $map['taxonomy'][ $tx ] ?? null;
	1308	+ $file = openstation_type_registrant_file( $tx, 'taxonomy' );
	1309	+ return null === $file ? null : openstation_plugin_file_for_path( $file );
855	1310	}
856	1311	return null;
857	1312	}
858	1313
859	1314	/**
860		- * Lazy accessor for the CPT/taxonomy → plugin file map. The map is
861		- * populated by `desktop_mode_record_type_registrant()` (hooked early on
	1315	+ * Lazy accessor for the CPT/taxonomy → registering-file map. The map is
	1316	+ * populated by `openstation_record_type_registrant()` (hooked on
	1317	+ * `registered_post_type` / `registered_taxonomy`, which fire during
862	1318	* `init`), so by the time the dock payload is built — on
863		- * `admin_enqueue_scripts`, well after `init` — every plugin-registered
864		- * non-builtin type has an entry. Stored in a static so repeated
865		- * lookups during a single request don't trigger the populator twice.
	1319	+ * `admin_enqueue_scripts`, well after `init` — every non-builtin type
	1320	+ * registered from an extension has an entry. Stored in a static so
	1321	+ * repeated lookups during a single request don't trigger the populator
	1322	+ * twice.
866	1323	*
	1324	+ * Values are **absolute filesystem paths**, not plugin files. Core does
	1325	+ * not load `wp-admin/includes/plugin.php` (where `get_plugins()` lives)
	1326	+ * until `wp-admin/admin.php` runs it *after* `wp-load.php` has already
	1327	+ * fired `init` — so a plugin file cannot be resolved at record time.
	1328	+ * Callers resolve the path lazily instead:
	1329	+ * `openstation_lookup_taxonomy_or_post_type_plugin_file()` for the
	1330	+ * dock's plugin attribution, and the My WordPress group resolver for
	1331	+ * the plugin / mu-plugin / theme split.
	1332	+ *
867	1333	* @return array{post_type: array<string,string>, taxonomy: array<string,string>}
868	1334	*/
869		-function &desktop_mode_get_typed_plugin_map() {
	1335	+function &openstation_get_typed_registrant_map() {
870	1336	static $map = null;
871	1337	if ( null === $map ) {
872	1338	$map = array(
873	1339	'post_type' => array(),
		@@ -877,9 +1343,58 @@
877	1343	return $map;
878	1344	}
879	1345
880	1346	/**
881		- * Record the registering plugin file for a CPT or taxonomy. Hooked at
	1347	+ * Read the recorded registering file for a CPT or taxonomy.
	1348	+ *
	1349	+ * @param string $type Type name (CPT or taxonomy).
	1350	+ * @param string $kind Either `'post_type'` or `'taxonomy'`.
	1351	+ * @return string|null Absolute normalized path, or null when unrecorded.
	1352	+ */
	1353	+function openstation_type_registrant_file( $type, $kind ) {
	1354	+ $map = openstation_get_typed_registrant_map();
	1355	+ return $map[ $kind ][ $type ] ?? null;
	1356	+}
	1357	+
	1358	+/**
	1359	+ * Whether this request will ever read the CPT / taxonomy attribution
	1360	+ * map, and is therefore worth paying a `debug_backtrace()` per
	1361	+ * non-builtin type registration to build it.
	1362	+ *
	1363	+ * Only admin-side surfaces consume it: the dock payload (built on
	1364	+ * `admin_enqueue_scripts`) and the site window's section list (built
	1365	+ * on `init`, admin only). A front-end page view registers exactly the
	1366	+ * same types — WooCommerce alone brings several — and would pay the
	1367	+ * whole cost for a map nothing reads.
	1368	+ *
	1369	+ * The predecessor of this function got the same effect by accident:
	1370	+ * it bailed when `get_plugins()` was undefined, which is every
	1371	+ * front-end request. That guard went away when the resolution moved to
	1372	+ * lazy path recording, so the gate is now explicit.
	1373	+ *
	1374	+ * @return bool
	1375	+ */
	1376	+function openstation_should_track_type_registrants() {
	1377	+ $track = is_admin();
	1378	+
	1379	+ /**
	1380	+ * Filter whether to record which extension registered each CPT and
	1381	+ * taxonomy this request.
	1382	+ *
	1383	+ * The map drives the dock's "Deactivate <plugin>" action and the
	1384	+ * site window's plugin folders. Return true on a front-end request
	1385	+ * only if something there reads it — building it costs one bounded
	1386	+ * backtrace per non-builtin type registration.
	1387	+ *
	1388	+ * **Status: Experimental**
	1389	+ *
	1390	+ * @param bool $track Default: admin requests only.
	1391	+ */
	1392	+ return (bool) apply_filters( 'openstation_track_type_registrants', $track );
	1393	+}
	1394	+
	1395	+/**
	1396	+ * Record the registering file for a CPT or taxonomy. Hooked at
882	1397	* `registered_post_type` / `registered_taxonomy` priority 9999 so we
883	1398	* fire after every other listener has run (lets a plugin re-register
884	1399	* its own type on top of someone else's — last writer wins, which
885	1400	* matches WP's runtime semantics).
		@@ -884,20 +1399,23 @@
884	1399	* its own type on top of someone else's — last writer wins, which
885	1400	* matches WP's runtime semantics).
886	1401	*
887	1402	* Resolution is via `debug_backtrace()`: walk frames until we hit one
888		- * whose `file` lives under `WP_PLUGIN_DIR`, then map the folder back
889		- * to a `get_plugins()` entry. Cheap — the backtrace is bounded to 12
890		- * frames and runs once per type registration, all during `init`.
	1403	+ * whose `file` lives inside an extension directory (plugins, mu-plugins,
	1404	+ * or a theme root). Cheap — the backtrace is bounded and runs once per
	1405	+ * type registration, all during `init`.
891	1406	*
892	1407	* @param string $type_or_post_type Type name (CPT or taxonomy).
893	1408	* @param string $kind Either `'post_type'` or `'taxonomy'`.
894	1409	* @return void
895	1410	*/
896		-function desktop_mode_record_type_registrant( $type_or_post_type, $kind ) {
	1411	+function openstation_record_type_registrant( $type_or_post_type, $kind ) {
897	1412	if ( '' === (string) $type_or_post_type ) {
898	1413	return;
899	1414	}
	1415	+ if ( ! openstation_should_track_type_registrants() ) {
	1416	+ return;
	1417	+ }
900	1418	// Skip Core builtin types — they're registered from Core itself
901	1419	// (Posts, Pages, Categories, …) and the backtrace would never land
902	1420	// inside WP_PLUGIN_DIR anyway. Cheap pre-filter.
903	1421	if ( 'post_type' === $kind ) {
		@@ -911,50 +1429,119 @@
911	1429	return;
912	1430	}
913	1431	}
914	1432
915		- $plugin_file = desktop_mode_plugin_file_for_callback_backtrace();
916		- if ( null === $plugin_file ) {
	1433	+ $file = openstation_registrant_file_from_backtrace();
	1434	+ if ( null === $file ) {
917	1435	return;
918	1436	}
919		- $map = &desktop_mode_get_typed_plugin_map();
920		- $map[ $kind ][ $type_or_post_type ] = $plugin_file;
	1437	+ $map = &openstation_get_typed_registrant_map();
	1438	+ $map[ $kind ][ $type_or_post_type ] = $file;
921	1439	}
922	1440
923	1441	/**
924		- * Walk the current PHP backtrace and return the plugin file owning
925		- * the closest frame inside `WP_PLUGIN_DIR`. Returns null when no
926		- * frame qualifies or when `get_plugins()` isn't available (Core
927		- * hasn't loaded `wp-admin/includes/plugin.php` yet — true on
928		- * non-admin requests and very early admin bootstrap).
	1442	+ * The extension directories a registration can legitimately come from,
	1443	+ * normalized and trailing-slashed. Anything else (Core itself, a
	1444	+ * drop-in, `wp-config.php`) is not attributable to an extension.
929	1445	*
	1446	+ * @return string[] Normalized directory prefixes.
	1447	+ */
	1448	+function openstation_extension_dirs() {
	1449	+ static $dirs = null;
	1450	+ if ( null !== $dirs ) {
	1451	+ return $dirs;
	1452	+ }
	1453	+ $dirs = array();
	1454	+ if ( defined( 'WP_PLUGIN_DIR' ) ) {
	1455	+ $dirs[] = wp_normalize_path( WP_PLUGIN_DIR ) . '/';
	1456	+ }
	1457	+ if ( defined( 'WPMU_PLUGIN_DIR' ) ) {
	1458	+ $dirs[] = wp_normalize_path( WPMU_PLUGIN_DIR ) . '/';
	1459	+ }
	1460	+ foreach ( (array) get_theme_roots() as $theme_root ) {
	1461	+ // `get_theme_roots()` returns roots relative to `wp-content`
	1462	+ // when there's only one; `get_theme_root()` normalizes that.
	1463	+ $dirs[] = wp_normalize_path( get_theme_root( (string) $theme_root ) ) . '/';
	1464	+ }
	1465	+ $dirs = array_values( array_unique( array_filter( $dirs ) ) );
	1466	+ return $dirs;
	1467	+}
	1468	+
	1469	+/**
	1470	+ * Walk the current PHP backtrace and return the closest frame that
	1471	+ * lives inside an extension directory (plugin, mu-plugin, or theme).
	1472	+ *
	1473	+ * Frames belonging to OpenStation itself are skipped: this function is
	1474	+ * called from `payload.php`, which is under `WP_PLUGIN_DIR`, so the two
	1475	+ * innermost frames would otherwise match and attribute every registered
	1476	+ * type to us.
	1477	+ *
930	1478	* Used by the CPT / taxonomy registration tracker to attribute
931		- * `register_post_type()` / `register_taxonomy()` calls without
932		- * forcing Core to load its admin include earlier than it would.
	1479	+ * `register_post_type()` / `register_taxonomy()` calls without forcing
	1480	+ * Core to load `wp-admin/includes/plugin.php` earlier than it would —
	1481	+ * `get_plugins()` does not exist yet at `init`.
933	1482	*
934		- * @return string|null Plugin file or null.
	1483	+ * @return string|null Normalized absolute path, or null.
935	1484	*/
936		-function desktop_mode_plugin_file_for_callback_backtrace() {
937		- if ( ! function_exists( 'get_plugins' ) ) {
	1485	+function openstation_registrant_file_from_backtrace() {
	1486	+ $self_dir = defined( 'OPENSTATION_DIR' ) ? wp_normalize_path( OPENSTATION_DIR ) : '';
	1487	+ $self_dir = $self_dir ? trailingslashit( $self_dir ) : '';
	1488	+ $dirs = openstation_extension_dirs();
	1489	+ if ( empty( $dirs ) ) {
938	1490	return null;
939	1491	}
940		- $bt = debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS, 12 );
	1492	+
	1493	+ $bt = debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS, 20 );
941	1494	foreach ( $bt as $frame ) {
942	1495	if ( empty( $frame['file'] ) ) {
943	1496	continue;
944	1497	}
945		- $plugin_file = desktop_mode_plugin_file_for_path( (string) $frame['file'] );
946		- if ( null !== $plugin_file ) {
947		- return $plugin_file;
	1498	+ $norm = wp_normalize_path( (string) $frame['file'] );
	1499	+ if ( '' !== $self_dir && 0 === strpos( $norm, $self_dir ) ) {
	1500	+ continue;
948	1501	}
	1502	+ $norm = openstation_plugin_link_path( $norm );
	1503	+ foreach ( $dirs as $dir ) {
	1504	+ if ( 0 === strpos( $norm, $dir ) ) {
	1505	+ return $norm;
	1506	+ }
	1507	+ }
949	1508	}
950	1509	return null;
951	1510	}
952	1511
	1512	+/**
	1513	+ * Map a path PHP reported back to the plugin folder WordPress loaded
	1514	+ * it through.
	1515	+ *
	1516	+ * PHP resolves symlinks in file names, so a plugin folder linked into
	1517	+ * `plugins/` from elsewhere shows up in backtraces and reflection outside
	1518	+ * `WP_PLUGIN_DIR`. WordPress.com's managed plugins are linked that way:
	1519	+ * `plugins/woocommerce` resolves to `/wordpress/plugins/woocommerce/<version>/`.
	1520	+ * Core records each active plugin's link and target in
	1521	+ * `$wp_plugin_paths` before loading it, and `plugin_basename()` maps
	1522	+ * through the same list.
	1523	+ *
	1524	+ * @param string $path Normalized absolute path.
	1525	+ * @return string The same file under the plugin's link, or `$path`
	1526	+ * when no active plugin is linked from there.
	1527	+ */
	1528	+function openstation_plugin_link_path( $path ) {
	1529	+ global $wp_plugin_paths;
	1530	+
	1531	+ foreach ( (array) $wp_plugin_paths as $link => $target ) {
	1532	+ $target = trailingslashit( (string) $target );
	1533	+ if ( 0 === strpos( $path, $target ) ) {
	1534	+ return trailingslashit( (string) $link ) . substr( $path, strlen( $target ) );
	1535	+ }
	1536	+ }
	1537	+ return $path;
	1538	+}
	1539	+
953	1540	add_action(
954	1541	'registered_post_type',
955	1542	static function ( $post_type ) {
956		- desktop_mode_record_type_registrant( $post_type, 'post_type' );
	1543	+ openstation_record_type_registrant( $post_type, 'post_type' );
957	1544	},
958	1545	9999,
959	1546	1
960	1547	);
		@@ -961,9 +1548,9 @@
961	1548
962	1549	add_action(
963	1550	'registered_taxonomy',
964	1551	static function ( $taxonomy ) {
965		- desktop_mode_record_type_registrant( $taxonomy, 'taxonomy' );
	1552	+ openstation_record_type_registrant( $taxonomy, 'taxonomy' );
966	1553	},
967	1554	9999,
968	1555	1
969	1556	);
		@@ -977,9 +1564,9 @@
977	1564	*
978	1565	* @param mixed $callback A callback as stored in `WP_Hook::$callbacks[$prio][$id]['function']`.
979	1566	* @return string|null Absolute filesystem path of the declaring file, or null.
980	1567	*/
981		-function desktop_mode_callback_source_file( $callback ) {
	1568	+function openstation_callback_source_file( $callback ) {
982	1569	if ( empty( $callback ) ) {
983	1570	return null;
984	1571	}
985	1572	try {
		@@ -984,9 +1571,9 @@
984	1571	}
985	1572	try {
986	1573	if ( is_string( $callback ) && false !== strpos( $callback, '::' ) ) {
987	1574	list( $class, $method ) = explode( '::', $callback, 2 );
988		- $ref = new ReflectionMethod( $class, $method );
	1575	+ $ref = new ReflectionMethod( $class, $method );
989	1576	} elseif ( is_array( $callback ) && isset( $callback[0], $callback[1] ) ) {
990	1577	$ref = new ReflectionMethod( $callback[0], (string) $callback[1] );
991	1578	} elseif ( is_object( $callback ) && ! ( $callback instanceof Closure ) && method_exists( $callback, '__invoke' ) ) {
992	1579	$ref = new ReflectionMethod( $callback, '__invoke' );
		@@ -1012,14 +1599,14 @@
1012	1599	* exists server-side; this only suppresses the
1013	1600	* desktop-shell tile.
1014	1601	*
1015	1602	* Default is `'dock'` for every menu item. Plugins + site admins can
1016		- * hide individual items via the `desktop_mode_dock_placement` filter.
	1603	+ * hide individual items via the `openstation_dock_placement` filter.
1017	1604	*
1018	1605	* @param string $menu_slug The menu slug (e.g. `edit.php`, `woocommerce`).
1019	1606	* @return string `'dock'` or `'hidden'`.
1020	1607	*/
1021		-function desktop_mode_dock_placement( $menu_slug ) {
	1608	+function openstation_dock_placement( $menu_slug ) {
1022	1609	/**
1023	1610	* Filter whether a specific menu item is shown in the dock.
1024	1611	*
1025	1612	* Return `'dock'` to render the item on the dock (default) or
		@@ -1029,9 +1616,9 @@
1029	1616	*
1030	1617	* @param string $placement Default — always `'dock'`.
1031	1618	* @param string $menu_slug The menu slug triggering the lookup.
1032	1619	*/
1033		- $filtered = apply_filters( 'desktop_mode_dock_placement', 'dock', $menu_slug );
	1620	+ $filtered = apply_filters( 'openstation_dock_placement', 'dock', $menu_slug );
1034	1621	return 'hidden' === $filtered ? 'hidden' : 'dock';
1035	1622	}
1036	1623
1037	1624	/**
		@@ -1043,16 +1630,16 @@
1043	1630	* `'hidden'` are dropped entirely.
1044	1631	*
1045	1632	* Extracted out of `includes/render.php` so both the initial PHP
1046	1633	* localize AND the chromeless bridge's live-refresh emit (including
1047		- * the hidden-iframe probe spawned by `wp.desktop.refreshMenu()`)
	1634	+ * the hidden-iframe probe spawned by `wp.os.refreshMenu()`)
1048	1635	* read from a single source of truth — any drift would desync the
1049	1636	* live refresh.
1050	1637	*
1051	1638	* @return array{dockItems: array[]} Menu payload.
1052	1639	*/
1053		-function desktop_mode_build_menu_payload() {
1054		- $all = desktop_mode_build_dock_items();
	1640	+function openstation_build_menu_payload() {
	1641	+ $all = openstation_build_dock_items();
1055	1642
1056	1643	// Drop hidden items; preserve the default "core first, plugins
1057	1644	// after" ordering by partitioning on the core classifier.
1058	1645	$visible = array_values(
		@@ -1064,14 +1651,14 @@
1064	1651	)
1065	1652	);
1066	1653
1067	1654	// Partition on the per-item `isCore` flag set in
1068		- // desktop_mode_build_dock_items — that classifier ran against the
	1655	+ // openstation_build_dock_items — that classifier ran against the
1069	1656	// raw menu slug ($item[2]), which is what
1070		- // desktop_mode_is_core_menu_slug actually compares. The outer 'id'
	1657	+ // openstation_is_core_menu_slug actually compares. The outer 'id'
1071	1658	// field is a sanitized CSS id (e.g. `toplevel_page_jetpack`) and
1072	1659	// would never match.
1073		- $core = array();
	1660	+ $core = array();
1074	1661	$plugin = array();
1075	1662	foreach ( $visible as $item ) {
1076	1663	if ( ! empty( $item['isCore'] ) ) {
1077	1664	$core[] = $item;
		@@ -1081,39 +1668,45 @@
1081	1668	}
1082	1669
1083	1670	$dock = array_merge( $core, $plugin );
1084	1671
	1672	+ // One collector call feeds both halves: the slim entry list and
	1673	+ // the handle-keyed script data the shell joins them with.
	1674	+ $native_windows = openstation_collect_native_windows_payload();
	1675	+
1085	1676	$payload = array(
1086		- 'dockItems' => $dock,
1087		- 'nativeWindows' => desktop_mode_build_native_windows_payload(),
	1677	+ 'dockItems' => $dock,
	1678	+ 'nativeWindows' => $native_windows['windows'],
	1679	+ 'nativeWindowScriptData' => $native_windows['scriptData'],
1088	1680	);
1089	1681
1090	1682	// Optional per-surface payload builders — each module ships a
1091		- // zero-arg `desktop_mode_build_*_payload()`; modules that aren't
	1683	+ // zero-arg `openstation_build_*_payload()`; modules that aren't
1092	1684	// loaded this request contribute an empty array.
1093	1685	$builders = array(
1094		- 'serverWidgets' => 'desktop_mode_build_desktop_widgets_payload',
1095		- 'serverWallpapers' => 'desktop_mode_build_desktop_wallpapers_payload',
1096		- 'serverCommandScripts' => 'desktop_mode_build_desktop_command_scripts_payload',
1097		- 'serverCommands' => 'desktop_mode_build_desktop_commands_payload',
1098		- 'serverSettingsTabScripts' => 'desktop_mode_build_desktop_settings_tab_scripts_payload',
1099		- 'serverSettingsTabs' => 'desktop_mode_build_desktop_settings_tabs_payload',
1100		- 'serverDockRailRendererScripts' => 'desktop_mode_build_dock_rail_renderer_scripts_payload',
1101		- 'serverTitleBarButtonScripts' => 'desktop_mode_build_desktop_titlebar_button_scripts_payload',
1102		- 'serverUnfocusEffectScripts' => 'desktop_mode_build_desktop_unfocus_effect_scripts_payload',
1103		- 'serverWindowLinkRendererScripts' => 'desktop_mode_build_window_link_renderer_scripts_payload',
1104		- 'serverWindowThemeScripts' => 'desktop_mode_build_window_theme_scripts_payload',
1105		- 'serverWindowThemes' => 'desktop_mode_build_window_themes_payload',
1106		- 'serverWindowControlScripts' => 'desktop_mode_build_window_control_scripts_payload',
1107		- 'serverWindowControls' => 'desktop_mode_build_window_controls_payload',
1108		- 'serverWindowSlotScripts' => 'desktop_mode_build_window_slot_scripts_payload',
1109		- 'serverWindowSlots' => 'desktop_mode_build_window_slots_payload',
1110		- 'serverWindowChromeScripts' => 'desktop_mode_build_window_chrome_scripts_payload',
1111		- 'serverWindowChromes' => 'desktop_mode_build_window_chromes_payload',
1112		- 'serverWindowNotices' => 'desktop_mode_build_window_notices_payload',
1113		- 'serverGames' => 'desktop_mode_build_desktop_games_payload',
1114		- 'serverDesktopThemes' => 'desktop_mode_build_desktop_themes_payload',
1115		- 'desktopIcons' => 'desktop_mode_build_desktop_icons_payload',
	1686	+ 'serverWidgets' => 'openstation_build_desktop_widgets_payload',
	1687	+ 'serverWallpapers' => 'openstation_build_desktop_wallpapers_payload',
	1688	+ 'serverCommandScripts' => 'openstation_build_desktop_command_scripts_payload',
	1689	+ 'serverCommands' => 'openstation_build_desktop_commands_payload',
	1690	+ 'serverSettingsTabScripts' => 'openstation_build_desktop_settings_tab_scripts_payload',
	1691	+ 'serverSettingsTabs' => 'openstation_build_desktop_settings_tabs_payload',
	1692	+ 'serverDockRailRendererScripts' => 'openstation_build_dock_rail_renderer_scripts_payload',
	1693	+ 'serverTitleBarButtonScripts' => 'openstation_build_desktop_titlebar_button_scripts_payload',
	1694	+ 'serverWindowActionScripts' => 'openstation_build_desktop_window_action_scripts_payload',
	1695	+ 'serverUnfocusEffectScripts' => 'openstation_build_desktop_unfocus_effect_scripts_payload',
	1696	+ 'serverWindowLinkRendererScripts' => 'openstation_build_window_link_renderer_scripts_payload',
	1697	+ 'serverWindowThemeScripts' => 'openstation_build_window_theme_scripts_payload',
	1698	+ 'serverWindowThemes' => 'openstation_build_window_themes_payload',
	1699	+ 'serverWindowControlScripts' => 'openstation_build_window_control_scripts_payload',
	1700	+ 'serverWindowControls' => 'openstation_build_window_controls_payload',
	1701	+ 'serverWindowSlotScripts' => 'openstation_build_window_slot_scripts_payload',
	1702	+ 'serverWindowSlots' => 'openstation_build_window_slots_payload',
	1703	+ 'serverWindowChromeScripts' => 'openstation_build_window_chrome_scripts_payload',
	1704	+ 'serverWindowChromes' => 'openstation_build_window_chromes_payload',
	1705	+ 'serverWindowNotices' => 'openstation_build_window_notices_payload',
	1706	+ 'serverGames' => 'openstation_build_desktop_games_payload',
	1707	+ 'serverDesktopThemes' => 'openstation_build_desktop_themes_payload',
	1708	+ 'desktopIcons' => 'openstation_build_desktop_icons_payload',
1116	1709	);
1117	1710
1118	1711	foreach ( $builders as $key => $builder ) {
1119	1712	$payload[ $key ] = function_exists( $builder ) ? $builder() : array();
		@@ -1142,16 +1735,28 @@
1142	1735	'url' => network_admin_url( 'update-core.php' ),
1143	1736	);
1144	1737	}
1145	1738
	1739	+ // The site switcher's rows: on a network, the instances this shell
	1740	+ // may switch to (`openstation_multisite_payload()`), null elsewhere.
	1741	+ // The Network app spends a menu refresh after every action that
	1742	+ // changes them (add, remove, join, leave, sync), so the row above
	1743	+ // overview's desktop tiles follows the registry without a reload.
	1744	+ $payload['multisite'] = openstation_multisite_payload();
	1745	+
1146	1746	// A cheap structural fingerprint of the admin menu the shell uses to
1147	1747	// decide whether a live refresh is warranted. Shipped in every full
1148	1748	// payload so the shell can seed / update its last-known signature
1149	1749	// without recomputing it client-side (which would risk drift from
1150	1750	// the server's capability-gated view). See
1151		- // desktop_mode_menu_signature().
1152		- $payload['menuSig'] = desktop_mode_menu_signature();
	1751	+ // openstation_menu_signature().
	1752	+ $payload['menuSig'] = openstation_menu_signature();
1153	1753
	1754	+ // Each script dependency's payload once, entries carry handles.
	1755	+ $script_dep_payloads = array();
	1756	+ $payload = openstation_compact_script_deps( $payload, $script_dep_payloads );
	1757	+ $payload['scriptDepPayloads'] = (object) $script_dep_payloads;
	1758	+
1154	1759	return $payload;
1155	1760	}
1156	1761
1157	1762	/**
		@@ -1169,9 +1774,9 @@
1169	1774	* Building the full payload on *every* chromeless page just to catch
1170	1775	* that case would be wasteful — most navigations don't touch the menu.
1171	1776	* Instead every chromeless page ships this lightweight signature; the
1172	1777	* shell compares it against its last-known value and only spends a
1173		- * `wp.desktop.refreshMenu()` probe when it actually changed.
	1778	+ * `wp.os.refreshMenu()` probe when it actually changed.
1174	1779	*
1175	1780	* The hash covers the capability-passing top-level + submenu slugs and
1176	1781	* their (badge-stripped) titles — i.e. exactly the add / remove /
1177	1782	* rename events the dock cares about. Transient badge counts (update
		@@ -1180,9 +1785,9 @@
1180	1785	*
1181	1786	* @return string 32-char md5 fingerprint, or '' when the menu is
1182	1787	* unavailable (non-admin context).
1183	1788	*/
1184		-function desktop_mode_menu_signature() {
	1789	+function openstation_menu_signature() {
1185	1790	global $menu, $submenu;
1186	1791
1187	1792	if ( empty( $menu ) || ! is_array( $menu ) ) {
1188	1793	return '';
		@@ -1188,9 +1793,9 @@
1188	1793	return '';
1189	1794	}
1190	1795
1191	1796	$clean_title = static function ( $raw ) {
1192		- // Mirror desktop_mode_build_dock_items(): drop badge spans first,
	1797	+ // Mirror openstation_build_dock_items(): drop badge spans first,
1193	1798	// then any remaining markup, so update counts don't move the hash.
1194	1799	$stripped = preg_replace( '/<span[^>]*>.*?<\/span>/s', '', (string) $raw );
1195	1800	return trim( wp_strip_all_tags( (string) $stripped ) );
1196	1801	};
		@@ -1226,8 +1831,247 @@
1226	1831	return md5( implode( "\n", $parts ) );
1227	1832	}
1228	1833
1229	1834	/**
	1835	+ * A handle's dependency closure, in load order.
	1836	+ *
	1837	+ * Post-order depth-first: a handle is emitted only after everything it
	1838	+ * declares, which is the order `WP_Scripts::do_item()` would have
	1839	+ * printed them in. A handle is marked visited *before* its own
	1840	+ * dependencies are walked, so a dependency cycle unwinds instead of
	1841	+ * recursing forever, and an unregistered handle is skipped rather than
	1842	+ * being fatal — it contributes nothing and stops nothing.
	1843	+ *
	1844	+ * **Deliberately not `WP_Dependencies::all_deps()`.** Three reasons,
	1845	+ * each of which has bitten this codebase:
	1846	+ *
	1847	+ * 1. `WP_Scripts::all_deps()` applies `print_scripts_array` to its
	1848	+ * result whenever `$recursion` is falsy. That filter is where the
	1849	+ * chromeless palette trim and the asset guard live, so resolving a
	1850	+ * payload through it would run a print-time trim across a dependency
	1851	+ * list and let the guard splice this plugin's own bundles into it.
	1852	+ * Called from inside one of those filters it is an infinite loop.
	1853	+ *
	1854	+ * 2. Passing `$recursion = true` silences that filter but changes the
	1855	+ * contract: the first handle that fails aborts the entire call
	1856	+ * (`return false`), abandoning every handle after it in the list. The
	1857	+ * caller is left with a `$to_do` that is a truncated prefix of the real
	1858	+ * closure and indistinguishable from a complete one — a silent, partial
	1859	+ * answer conditional on unrelated registrations elsewhere on the page.
	1860	+ * A lazily-delivered bundle resolved that way loses packages it
	1861	+ * declared and throws on an undefined global at mount, which is the
	1862	+ * exact bug this whole mechanism exists to prevent.
	1863	+ *
	1864	+ * 3. `all_deps()` reports missing dependencies through
	1865	+ * `_doing_it_wrong()`. This is read-only analysis; the real print pass
	1866	+ * raises those anyway, and raising them twice turns someone else's
	1867	+ * pre-existing warning into our noise.
	1868	+ *
	1869	+ * O(V+E) over the graph, allocates one set, and clones nothing.
	1870	+ *
	1871	+ * @param WP_Dependencies $dependencies The scripts or styles registry.
	1872	+ * @param string[] $handles Roots to walk.
	1873	+ * @return string[] Registered handles, dependencies before dependents.
	1874	+ */
	1875	+function openstation_script_dependency_closure( $dependencies, $handles ) {
	1876	+ $seen = array();
	1877	+ $out = array();
	1878	+ openstation_collect_script_dependency_closure( $dependencies, (array) $handles, $seen, $out );
	1879	+
	1880	+ return $out;
	1881	+}
	1882	+
	1883	+/**
	1884	+ * Recursive half of {@see openstation_script_dependency_closure()}.
	1885	+ *
	1886	+ * @param WP_Dependencies $dependencies The scripts or styles registry.
	1887	+ * @param string[] $handles Handles to walk.
	1888	+ * @param array $seen Handle => true, by reference.
	1889	+ * @param string[] $out Ordered result, by reference.
	1890	+ */
	1891	+function openstation_collect_script_dependency_closure( $dependencies, $handles, &$seen, &$out ) {
	1892	+ foreach ( (array) $handles as $handle ) {
	1893	+ if ( isset( $seen[ $handle ] ) ) {
	1894	+ continue;
	1895	+ }
	1896	+ // Marked BEFORE recursing, so a cycle meets itself as visited
	1897	+ // and unwinds rather than recursing forever.
	1898	+ $seen[ $handle ] = true;
	1899	+ if ( ! isset( $dependencies->registered[ $handle ] ) ) {
	1900	+ continue;
	1901	+ }
	1902	+ openstation_collect_script_dependency_closure(
	1903	+ $dependencies,
	1904	+ $dependencies->registered[ $handle ]->deps,
	1905	+ $seen,
	1906	+ $out
	1907	+ );
	1908	+ $out[] = $handle;
	1909	+ }
	1910	+}
	1911	+
	1912	+/**
	1913	+ * Resolve a handle's dependency closure, in load order.
	1914	+ *
	1915	+ * **Why a lazily-delivered handle needs this at all.** WordPress
	1916	+ * normally resolves a script's dependencies when it enqueues it — the
	1917	+ * packages a bundle declares are on the page before its own body runs.
	1918	+ * A handle that is only ever delivered lazily never goes through that:
	1919	+ * `loadVendorScript()` injects one URL, and a bundle declaring
	1920	+ * `wp-api-fetch` found `wp.apiFetch` undefined at mount.
	1921	+ *
	1922	+ * That used to work by accident. Core's ⌘K palette was enqueued on
	1923	+ * every admin page and its closure is the whole Gutenberg runtime, so
	1924	+ * `wp.apiFetch`, `wp.element` and friends happened to be globals.
	1925	+ * Deferring the palette took the accident away and left the contract
	1926	+ * exposed — see `docs/migration-wp-package-globals.md`.
	1927	+ *
	1928	+ * The closure comes from {@see openstation_script_dependency_closure()}
	1929	+ * rather than `WP_Dependencies::all_deps()`; that function's docblock
	1930	+ * records why, and the short version is that `all_deps()` answers a
	1931	+ * question like this one with a silently truncated list. The handle
	1932	+ * itself is excluded — the caller loads it separately, after these.
	1933	+ *
	1934	+ * @param string $handle Script handle.
	1935	+ * @return array<int,array<string,mixed>> Ordered dependency payloads.
	1936	+ */
	1937	+function openstation_resolve_script_dependencies( $handle ) {
	1938	+ $handle = (string) $handle;
	1939	+ $wp_scripts = wp_scripts();
	1940	+ if ( '' === $handle || ! $wp_scripts || ! isset( $wp_scripts->registered[ $handle ] ) ) {
	1941	+ return array();
	1942	+ }
	1943	+ $deps = $wp_scripts->registered[ $handle ]->deps;
	1944	+ if ( empty( $deps ) ) {
	1945	+ return array();
	1946	+ }
	1947	+
	1948	+ $out = array();
	1949	+ foreach ( openstation_script_dependency_closure( $wp_scripts, $deps ) as $dep_handle ) {
	1950	+ if ( $dep_handle === $handle ) {
	1951	+ continue;
	1952	+ }
	1953	+ $payload = openstation_resolve_script_payload( $dep_handle );
	1954	+ // An alias (no `src`) stays in the list when it carries inline
	1955	+ // data — that data is the whole reason it was declared, and a
	1956	+ // plugin's config blob commonly rides one. Nothing to fetch
	1957	+ // AND nothing to run is the only thing dropped.
	1958	+ if ( '' === $payload['url']
	1959	+ && empty( $payload['before'] )
	1960	+ && empty( $payload['after'] )
	1961	+ && empty( $payload['l10n'] ) ) {
	1962	+ continue;
	1963	+ }
	1964	+ // The handle rides along because the shell needs it to decide
	1965	+ // whether the page already has this package. A URL is not
	1966	+ // enough: with Core's script concatenation on — the wp-admin
	1967	+ // default — every package below `wp-includes/js/` is served
	1968	+ // from one `load-scripts.php` blob and has no `<script src>`
	1969	+ // of its own to match against. Re-running `wp-hooks` because
	1970	+ // we could not see it replaces `window.wp.hooks`, and every
	1971	+ // subscriber registered at boot goes deaf. See
	1972	+ // `src/script-presence.ts`.
	1973	+ $payload['handle'] = (string) $dep_handle;
	1974	+ $out[] = $payload;
	1975	+ }
	1976	+ return $out;
	1977	+}
	1978	+
	1979	+/**
	1980	+ * Move every entry's `scriptDeps` payloads into one map.
	1981	+ *
	1982	+ * {@see openstation_resolve_script_dependencies()} returns the full
	1983	+ * payload of each dependency (URL, l10n, before/after), and ~20 entry
	1984	+ * builders call it. A dependency shared by N entries was therefore
	1985	+ * serialized N times: one plugin's 5.5 KB localized object became
	1986	+ * ~400 KB of a 489 KB `openStationConfig` (GH#892). This replaces each
	1987	+ * entry's `scriptDeps` list with its handles and puts each handle's
	1988	+ * payload in `$map` once. The shell resolves the handles back before
	1989	+ * any consumer reads them; see `src/script-dep-payloads.ts`.
	1990	+ *
	1991	+ * ENTRY DEPTH ONLY. `$payload` is a payload whose top-level values are
	1992	+ * entry lists (`serverWidgets`, `serverCommandScripts`, ...), and only
	1993	+ * a `scriptDeps` sitting directly on one of those entries is touched.
	1994	+ * The key is the shell's there. Deeper down it is a plugin's metadata
	1995	+ * (`settings => [ 'scriptDeps' => ... ]`), and rewriting it would hoist
	1996	+ * foreign data into the map first-wins and hydrate every real
	1997	+ * dependency of that handle to it. Scoping by depth rather than by a
	1998	+ * list of keys means a new builder is covered without an edit here.
	1999	+ * It also leaves every other branch of the payload unassigned, so
	2000	+ * PHP's copy-on-write never has to copy them.
	2001	+ *
	2002	+ * Every string left in a compacted list has an entry in `$map`: a bare
	2003	+ * handle a builder (or a filter on one) emitted is resolved here, by
	2004	+ * the same rule as {@see openstation_resolve_script_dependencies()}.
	2005	+ * A handle with nothing to fetch and nothing to run is dropped, as it
	2006	+ * is there. The client can then treat a string with no map entry as a
	2007	+ * payload from somewhere else, not a dependency this side dropped.
	2008	+ *
	2009	+ * Runs on the finished payload, so every builder, and every filter on
	2010	+ * a builder's output, still sees the full shape.
	2011	+ *
	2012	+ * @param array $payload Payload whose top-level values are entry lists.
	2013	+ * @param array $map Handle => dependency payload, filled in place.
	2014	+ * @return array The payload with each entry's `scriptDeps` reduced to handles.
	2015	+ */
	2016	+function openstation_compact_script_deps( $payload, array &$map ) {
	2017	+ if ( ! is_array( $payload ) ) {
	2018	+ return $payload;
	2019	+ }
	2020	+ foreach ( $payload as $list_key => $entries ) {
	2021	+ if ( ! is_array( $entries ) ) {
	2022	+ continue;
	2023	+ }
	2024	+ foreach ( $entries as $entry_key => $entry ) {
	2025	+ if ( ! is_array( $entry ) || ! isset( $entry['scriptDeps'] ) || ! is_array( $entry['scriptDeps'] ) ) {
	2026	+ continue;
	2027	+ }
	2028	+ $payload[ $list_key ][ $entry_key ]['scriptDeps'] = openstation_compact_script_dep_list( $entry['scriptDeps'], $map );
	2029	+ }
	2030	+ }
	2031	+ return $payload;
	2032	+}
	2033	+
	2034	+/**
	2035	+ * One entry's `scriptDeps` list, reduced to handles.
	2036	+ *
	2037	+ * @param array $deps Dependency payloads and/or bare handles.
	2038	+ * @param array $map Handle => dependency payload, filled in place.
	2039	+ * @return array Handles, in order; anything unkeyable passes through.
	2040	+ */
	2041	+function openstation_compact_script_dep_list( array $deps, array &$map ) {
	2042	+ $handles = array();
	2043	+ foreach ( $deps as $dep ) {
	2044	+ if ( is_string( $dep ) && '' !== $dep ) {
	2045	+ if ( ! isset( $map[ $dep ] ) ) {
	2046	+ $payload = openstation_resolve_script_payload( $dep );
	2047	+ if ( '' === $payload['url']
	2048	+ && empty( $payload['before'] )
	2049	+ && empty( $payload['after'] )
	2050	+ && empty( $payload['l10n'] ) ) {
	2051	+ continue;
	2052	+ }
	2053	+ $payload['handle'] = $dep;
	2054	+ $map[ $dep ] = $payload;
	2055	+ }
	2056	+ $handles[] = $dep;
	2057	+ continue;
	2058	+ }
	2059	+ if ( is_array( $dep ) && isset( $dep['handle'] ) && '' !== (string) $dep['handle'] ) {
	2060	+ $handle = (string) $dep['handle'];
	2061	+ if ( ! isset( $map[ $handle ] ) ) {
	2062	+ $map[ $handle ] = $dep;
	2063	+ }
	2064	+ $handles[] = $handle;
	2065	+ continue;
	2066	+ }
	2067	+ // A handle-less payload has nothing to key it by.
	2068	+ $handles[] = $dep;
	2069	+ }
	2070	+ return $handles;
	2071	+}
	2072	+
	2073	+/**
1230	2074	* Resolve a registered WP script handle into the full payload the
1231	2075	* shell needs to lazy-load it without going through `wp_print_scripts()`.
1232	2076	*
1233	2077	* Returns:
		@@ -1251,13 +2095,17 @@
1251	2095	* around the lazy `<script src>` in the same order
1252	2096	* `WP_Scripts::do_item()` would have used.
1253	2097	*
1254	2098	* Returns an empty payload (`array( 'url' => '' )`) when the handle
1255		- * is unregistered or has no source — callers treat that as "no
1256		- * script to load."
	2099	+ * is unregistered. A registered handle with no source — an alias
	2100	+ * carrying only inline data — also comes back with an empty `url`,
	2101	+ * but its `before` / `after` / `l10n` are kept: callers that load a
	2102	+ * bundle treat an empty `url` as "nothing to fetch", and the
	2103	+ * dependency walk ({@see openstation_resolve_script_dependencies()})
	2104	+ * still replays what the alias would have printed.
1257	2105	*
1258		- * Shared between `desktop_mode_register_window()` and
1259		- * `desktop_mode_register_widget()` (and every other registration that
	2106	+ * Shared between `openstation_register_window()` and
	2107	+ * `openstation_register_widget()` (and every other registration that
1260	2108	* relies on lazy script loading in the shell) because all of them
1261	2109	* need identical handle→payload plumbing to power mid-session dynamic
1262	2110	* script loading without the `wp_print_scripts` lifecycle.
1263	2111	*
		@@ -1263,9 +2111,9 @@
1263	2111	*
1264	2112	* @param string $handle WP script handle.
1265	2113	* @return array{ url:string, before:string[], after:string[], l10n:string[], translations:string } Payload (empty `url` on miss).
1266	2114	*/
1267		-function desktop_mode_resolve_script_payload( $handle ) {
	2115	+function openstation_resolve_script_payload( $handle ) {
1268	2116	$empty = array(
1269	2117	'url' => '',
1270	2118	'before' => array(),
1271	2119	'after' => array(),
		@@ -1282,20 +2130,31 @@
1282	2130	return $empty;
1283	2131	}
1284	2132	$registered = $wp_scripts->registered[ $handle ];
1285	2133	$src = is_string( $registered->src ) ? $registered->src : '';
1286		- if ( '' === $src ) {
1287		- return $empty;
1288		- }
1289	2134
1290		- // Normalize relative paths + attach cache-bust ver.
1291		- $resolved = $src;
1292		- if ( 0 === strpos( $resolved, '/' ) && 0 !== strpos( $resolved, '//' ) ) {
1293		- $resolved = site_url( $resolved );
	2135	+ // A handle with no `src` is an ALIAS — WordPress's supported way
	2136	+ // to ship inline-only JavaScript (`wp_register_script( $h, false )`
	2137	+ // plus `wp_add_inline_script()`), and a common home for a plugin's
	2138	+ // config blob: registering it as a *dependency* of every bundle is
	2139	+ // what guarantees the config runs first, whatever the enqueue
	2140	+ // order. `WP_Scripts::do_item()` prints an alias's localized data
	2141	+ // and its before/after snippets and returns before the `<script
	2142	+ // src>` it does not have. The payload mirrors that: `url` stays
	2143	+ // empty (there is nothing to fetch) and the inline data is kept,
	2144	+ // so a dependency walk can replay it. Translations are not: Core
	2145	+ // only prints those for a handle it printed a tag for.
	2146	+ $resolved = '';
	2147	+ if ( '' !== $src ) {
	2148	+ // Normalize relative paths + attach cache-bust ver.
	2149	+ $resolved = $src;
	2150	+ if ( 0 === strpos( $resolved, '/' ) && 0 !== strpos( $resolved, '//' ) ) {
	2151	+ $resolved = site_url( $resolved );
	2152	+ }
	2153	+ if ( ! empty( $registered->ver ) ) {
	2154	+ $resolved = add_query_arg( 'ver', $registered->ver, $resolved );
	2155	+ }
1294	2156	}
1295		- if ( ! empty( $registered->ver ) ) {
1296		- $resolved = add_query_arg( 'ver', $registered->ver, $resolved );
1297		- }
1298	2157
1299	2158	// Harvest `extra` data the lazy-load path would otherwise drop.
1300	2159	$before = array();
1301	2160	$after = array();
		@@ -1330,9 +2189,9 @@
1330	2189	// `wp.i18n.setLocaleData( JSON, 'domain' )` snippet that the print
1331	2190	// pipeline emits before the script body. `print_translations(
1332	2191	// $handle, false )` returns the snippet without echoing.
1333	2192	$translations = '';
1334		- if ( method_exists( $wp_scripts, 'print_translations' ) ) {
	2193	+ if ( '' !== $resolved && method_exists( $wp_scripts, 'print_translations' ) ) {
1335	2194	$captured = $wp_scripts->print_translations( $handle, false );
1336	2195	if ( is_string( $captured ) ) {
1337	2196	$translations = $captured;
1338	2197	}
		@@ -1349,9 +2208,9 @@
1349	2208
1350	2209	/**
1351	2210	* Resolves a registered style handle to its print-time URL + harvested
1352	2211	* inline CSS, the styles-side mirror of
1353		- * {@see desktop_mode_resolve_script_payload()}.
	2212	+ * {@see openstation_resolve_script_payload()}.
1354	2213	*
1355	2214	* Why this exists: when a plugin's native window (or window-chrome
1356	2215	* theme/control/slot/chrome) is activated mid-session — i.e. the user
1357	2216	* activates the plugin from inside an open desktop shell — the parent
		@@ -1367,9 +2226,9 @@
1367	2226	*
1368	2227	* @param string $handle WP style handle.
1369	2228	* @return array{ url:string, inline:string[] } Payload (empty `url` on miss).
1370	2229	*/
1371		-function desktop_mode_resolve_style_payload( $handle ) {
	2230	+function openstation_resolve_style_payload( $handle ) {
1372	2231	$empty = array(
1373	2232	'url' => '',
1374	2233	'inline' => array(),
1375	2234	);
		@@ -1419,22 +2278,206 @@
1419	2278	);
1420	2279	}
1421	2280
1422	2281	/**
	2282	+ * Build the deferred command-palette asset manifest.
	2283	+ *
	2284	+ * `wp_enqueue_command_palette_assets()` (WP 6.9+) enqueues
	2285	+ * `wp-commands` + `wp-core-commands` and attaches the inline
	2286	+ * `wp.coreCommands.initializeCommandPalette( … )` call that seeds the
	2287	+ * `core/commands` store. Its transitive dependency chain is the whole
	2288	+ * Gutenberg runtime — `wp-block-editor`, `wp-components`, React,
	2289	+ * `wp-core-data`, some forty bundles, ~800 KB gzipped — which the
	2290	+ * shell used to pay on EVERY boot so that the ⌘K palette's baseline
	2291	+ * commands existed if the user ever opened it.
	2292	+ *
	2293	+ * This builder lets Core do exactly what it would have done — the
	2294	+ * menu-command serialization and the inline init included — then
	2295	+ * UNWINDS the enqueue: it snapshots the script/style queues, calls
	2296	+ * the Core function, diffs out the roots it added, restores the
	2297	+ * queues so nothing prints at boot, and resolves the full ordered
	2298	+ * dependency chain on CLONES (the live `$to_do` is never touched).
	2299	+ * Each handle in the chain is harvested into the same
	2300	+ * url/before/after/l10n/translations shape the native-window lazy
	2301	+ * loader uses, and the shell replays the list — in order — the first
	2302	+ * time the palette is invoked (`src/commands/palette-assets.ts`).
	2303	+ *
	2304	+ * Handles with no `src` (pure aggregators) are kept whenever they
	2305	+ * carry inline data; dropping them would lose middleware and locale
	2306	+ * setup the chain depends on. Handles the boot page already printed
	2307	+ * are skipped client-side, by handle as well as by path so that a
	2308	+ * package Core concatenated into `load-scripts.php` is recognized
	2309	+ * (`src/script-presence.ts`) — the manifest deliberately lists them
	2310	+ * anyway, because which ones those are differs per site and per
	2311	+ * screen. Each entry therefore carries its `handle`, and that is
	2312	+ * load-bearing rather than informational.
	2313	+ *
	2314	+ * Returns `null` on pre-6.9 sites (no Core palette to defer).
	2315	+ *
	2316	+ * @return array{scripts:array<int,array<string,mixed>>,styles:array<int,array<string,mixed>>}|null
	2317	+ */
	2318	+function openstation_build_command_palette_assets_payload() {
	2319	+ if ( ! function_exists( 'wp_enqueue_command_palette_assets' ) ) {
	2320	+ return null;
	2321	+ }
	2322	+ $scripts = wp_scripts();
	2323	+ $styles = wp_styles();
	2324	+ if ( ! $scripts || ! $styles ) {
	2325	+ return null;
	2326	+ }
	2327	+
	2328	+ // `wp_enqueue_command_palette_assets()` reads `$submenu` without
	2329	+ // guarding the global — initialize defensively (test contexts,
	2330	+ // edge-case admin requests where the menu wasn't built yet).
	2331	+ global $menu, $submenu;
	2332	+ // phpcs:disable WordPress.WP.GlobalVariablesOverride.Prohibited -- initializing an unset global to its documented empty shape, not replacing a built menu.
	2333	+ if ( ! isset( $submenu ) || ! is_array( $submenu ) ) {
	2334	+ $submenu = array();
	2335	+ }
	2336	+ if ( ! isset( $menu ) || ! is_array( $menu ) ) {
	2337	+ $menu = array();
	2338	+ }
	2339	+ // phpcs:enable WordPress.WP.GlobalVariablesOverride.Prohibited
	2340	+
	2341	+ $script_queue_before = $scripts->queue;
	2342	+ $style_queue_before = $styles->queue;
	2343	+
	2344	+ wp_enqueue_command_palette_assets();
	2345	+
	2346	+ $script_roots = array_values( array_diff( $scripts->queue, $script_queue_before ) );
	2347	+ $style_roots = array_values( array_diff( $styles->queue, $style_queue_before ) );
	2348	+
	2349	+ // Unwind: the boot page must not print any of it. The inline init
	2350	+ // stays attached to the `wp-core-commands` HANDLE — that is the
	2351	+ // point: the harvest below captures it, and if some other screen
	2352	+ // legitimately enqueues the handle, it prints as Core intended.
	2353	+ $scripts->queue = $script_queue_before;
	2354	+ $styles->queue = $style_queue_before;
	2355	+
	2356	+ $out = array(
	2357	+ 'scripts' => array(),
	2358	+ 'styles' => array(),
	2359	+ );
	2360	+
	2361	+ // Ordered dependency chains, resolved on clones so the request's
	2362	+ // real `$to_do` / `$done` state is untouched.
	2363	+ $script_probe = clone $scripts;
	2364	+ $script_probe->to_do = array();
	2365	+ $script_probe->done = array();
	2366	+ $script_probe->all_deps( $script_roots );
	2367	+ foreach ( $script_probe->to_do as $handle ) {
	2368	+ $payload = openstation_resolve_script_payload( $handle );
	2369	+ // A src-less aggregator is kept only for its inline data — the
	2370	+ // resolver harvests that for an alias — and dropped when it
	2371	+ // carries none.
	2372	+ if ( '' === $payload['url']
	2373	+ && empty( $payload['before'] )
	2374	+ && empty( $payload['after'] )
	2375	+ && empty( $payload['l10n'] ) ) {
	2376	+ continue;
	2377	+ }
	2378	+ // Core's `initializeCommandPalette( {…} )` inline embeds the
	2379	+ // serialized admin-menu command list — ~20 KB that the boot
	2380	+ // page ALREADY carries as `window.__openStationMenuCommands`
	2381	+ // (the shell harvester's lookup, attached as a `before`
	2382	+ // inline on the main bundle, and the richer of the two: its
	2383	+ // URL derivation routes legacy file-path slugs through
	2384	+ // `menu_page_url()` where Core's regex takes them literally).
	2385	+ // Ship the list once: strip Core's embedded copy and
	2386	+ // synthesize the same call against the global, which is
	2387	+ // guaranteed present long before the manifest replays — it
	2388	+ // prints at boot, the replay waits for the first ⌘K.
	2389	+ if ( 'wp-core-commands' === $handle ) {
	2390	+ foreach ( array( 'before', 'after' ) as $position ) {
	2391	+ $payload[ $position ] = array_values(
	2392	+ array_filter(
	2393	+ $payload[ $position ],
	2394	+ static function ( $snippet ) {
	2395	+ return false === strpos( (string) $snippet, 'initializeCommandPalette(' );
	2396	+ }
	2397	+ )
	2398	+ );
	2399	+ }
	2400	+ $payload['after'][] = sprintf(
	2401	+ 'wp.coreCommands.initializeCommandPalette({"is_network_admin":%s,"menu_commands":window.__openStationMenuCommands||[]});',
	2402	+ is_network_admin() ? 'true' : 'false'
	2403	+ );
	2404	+ }
	2405	+
	2406	+ $out['scripts'][] = array(
	2407	+ 'handle' => (string) $handle,
	2408	+ 'url' => $payload['url'],
	2409	+ 'before' => $payload['before'],
	2410	+ 'after' => $payload['after'],
	2411	+ 'l10n' => $payload['l10n'],
	2412	+ 'translations' => $payload['translations'],
	2413	+ );
	2414	+ }
	2415	+
	2416	+ $style_probe = clone $styles;
	2417	+ $style_probe->to_do = array();
	2418	+ $style_probe->done = array();
	2419	+ $style_probe->all_deps( $style_roots );
	2420	+ foreach ( $style_probe->to_do as $handle ) {
	2421	+ $style_payload = openstation_resolve_style_payload( $handle );
	2422	+ if ( '' === $style_payload['url'] ) {
	2423	+ continue;
	2424	+ }
	2425	+ $out['styles'][] = array(
	2426	+ 'handle' => (string) $handle,
	2427	+ 'url' => $style_payload['url'],
	2428	+ 'inline' => $style_payload['inline'],
	2429	+ );
	2430	+ }
	2431	+
	2432	+ return $out;
	2433	+}
	2434	+
	2435	+/**
	2436	+ * Resolve a list of style handles into the `deferredStyles` config
	2437	+ * map: handle → `array( 'url' => …, 'inline' => string[] )`.
	2438	+ *
	2439	+ * For shell surfaces that render on demand but are NOT native
	2440	+ * windows — the Preferences panel, the AI assistant, the bug-report
	2441	+ * window — so the `styles` companion mechanism can't carry their
	2442	+ * CSS. The shell reads this map off `openStationConfig.deferredStyles`
	2443	+ * and injects each sheet the first time its surface opens
	2444	+ * (`ensureDeferredStyle()` in `src/deferred-styles.ts`).
	2445	+ *
	2446	+ * Handles that resolve to nothing (never registered) are dropped, so
	2447	+ * the client map only ever holds injectable entries.
	2448	+ *
	2449	+ * @param string[] $handles Registered style handles.
	2450	+ * @return array<string, array{url:string, inline:string[]}>
	2451	+ */
	2452	+function openstation_build_deferred_styles( $handles ) {
	2453	+ $out = array();
	2454	+ foreach ( (array) $handles as $handle ) {
	2455	+ $handle = (string) $handle;
	2456	+ $payload = openstation_resolve_style_payload( $handle );
	2457	+ if ( '' === $payload['url'] ) {
	2458	+ continue;
	2459	+ }
	2460	+ $out[ $handle ] = $payload;
	2461	+ }
	2462	+ return $out;
	2463	+}
	2464	+
	2465	+/**
1423	2466	* Fire a `_doing_it_wrong()` notice exactly once per handle per
1424		- * request. Shared by every `desktop_mode_build_desktop_*_scripts_payload()`
	2467	+ * request. Shared by every `openstation_build_desktop_*_scripts_payload()`
1425	2468	* caller — payload builders run on every shell-config rebuild
1426	2469	* (multiple times per page load via REST + admin-bar refresh +
1427	2470	* tests), so undeduped notices spam the error log AND trip
1428	2471	* `expectedIncorrectUsage` assertions in unrelated tests.
1429	2472	*
1430		- * @param string $function_name `desktop_mode_register_*_script` — passed verbatim to `_doing_it_wrong`.
	2473	+ * @param string $function_name `openstation_register_*_script` — passed verbatim to `_doing_it_wrong`.
1431	2474	* @param string $kind Human label: `Command`, `Settings-tab`, `Title-bar button`.
1432	2475	* @param string $handle Offending script handle.
1433	2476	*/
1434		-function desktop_mode_warn_unresolvable_script_handle( $function_name, $kind, $handle ) {
	2477	+function openstation_warn_unresolvable_script_handle( $function_name, $kind, $handle ) {
1435	2478	static $warned = array();
1436		- $cache_key = $function_name . '|' . $handle;
	2479	+ $cache_key = $function_name . '|' . $handle;
1437	2480	if ( isset( $warned[ $cache_key ] ) ) {
1438	2481	return;
1439	2482	}
1440	2483	$warned[ $cache_key ] = true;
		@@ -1449,9 +2492,9 @@
1449	2492	_doing_it_wrong(
1450	2493	esc_html( $function_name ),
1451	2494	sprintf(
1452	2495	/* translators: 1: kind ("Command"/"Settings-tab"/"Title-bar button"), 2: handle. */
1453		- esc_html__( '%1$s script handle "%2$s" is not registered with WordPress (no `wp_register_script` call found). The script will not load.', 'desktop-mode' ),
	2496	+ esc_html__( '%1$s script handle "%2$s" could not be resolved: no `wp_register_script( \'%2$s\', … )` call had run by the time the shell harvested its payload. Register the handle on `admin_enqueue_scripts` at priority 5 or earlier — the harvest itself runs at priority 10, and a handle registered alongside it may or may not exist yet depending on plugin load order. Until then the script will not load.', 'desktop-mode' ),
1454	2497	esc_html( $kind ),
1455	2498	esc_html( $handle )
1456	2499	),
1457	2500	'0.8.1'
		@@ -1463,25 +2506,26 @@
1463	2506	* cache for the unresolvable-handle notice. Tests call this in
1464	2507	* `set_up` so prior tests' synthetic handles can't leak into
1465	2508	* later assertions about payload shape.
1466	2509	*/
1467		-function desktop_mode_flush_script_handle_registries() {
	2510	+function openstation_flush_script_handle_registries() {
1468	2511	$flushers = array(
1469		- 'desktop_mode_flush_desktop_command_script_registry',
1470		- 'desktop_mode_flush_desktop_settings_tab_script_registry',
1471		- 'desktop_mode_flush_dock_rail_renderer_script_registry',
1472		- 'desktop_mode_flush_desktop_titlebar_button_script_registry',
1473		- 'desktop_mode_flush_desktop_unfocus_effect_script_registry',
1474		- 'desktop_mode_flush_window_link_renderer_script_registry',
1475		- 'desktop_mode_flush_window_theme_script_registry',
1476		- 'desktop_mode_flush_window_theme_registry',
1477		- 'desktop_mode_flush_window_control_script_registry',
1478		- 'desktop_mode_flush_window_control_registry',
1479		- 'desktop_mode_flush_window_slot_script_registry',
1480		- 'desktop_mode_flush_window_slot_registry',
1481		- 'desktop_mode_flush_window_chrome_script_registry',
1482		- 'desktop_mode_flush_window_chrome_registry',
1483		- 'desktop_mode_flush_window_notice_registry',
	2512	+ 'openstation_flush_desktop_command_script_registry',
	2513	+ 'openstation_flush_desktop_settings_tab_script_registry',
	2514	+ 'openstation_flush_dock_rail_renderer_script_registry',
	2515	+ 'openstation_flush_desktop_titlebar_button_script_registry',
	2516	+ 'openstation_flush_desktop_window_action_script_registry',
	2517	+ 'openstation_flush_desktop_unfocus_effect_script_registry',
	2518	+ 'openstation_flush_window_link_renderer_script_registry',
	2519	+ 'openstation_flush_window_theme_script_registry',
	2520	+ 'openstation_flush_window_theme_registry',
	2521	+ 'openstation_flush_window_control_script_registry',
	2522	+ 'openstation_flush_window_control_registry',
	2523	+ 'openstation_flush_window_slot_script_registry',
	2524	+ 'openstation_flush_window_slot_registry',
	2525	+ 'openstation_flush_window_chrome_script_registry',
	2526	+ 'openstation_flush_window_chrome_registry',
	2527	+ 'openstation_flush_window_notice_registry',
1484	2528	);
1485	2529
1486	2530	foreach ( $flushers as $flusher ) {
1487	2531	if ( function_exists( $flusher ) ) {
		@@ -1488,32 +2532,157 @@
1488	2532	$flusher();
1489	2533	}
1490	2534	}
1491	2535
1492		- desktop_mode_warn_unresolvable_script_handle( '', '', '__flush__' );
	2536	+ openstation_warn_unresolvable_script_handle( '', '', '__flush__' );
1493	2537	}
1494	2538
1495	2539	/**
1496		- * Serialize the server-declared native-window registry into the
1497		- * payload shape the shell consumes. For each entry registered via
1498		- * `desktop_mode_register_window()`, we capture: the window's
1499		- * metadata (id/title/icon/placement/dimensions/autofocus), the
1500		- * rendered template HTML (by running the template callback into an
1501		- * output buffer), and the URL of the enqueued script handle (so
1502		- * mid-session activations can load the plugin's JS dynamically
1503		- * without a full shell reload).
	2540	+ * Collect the native-window payload: slim per-window entries plus a
	2541	+ * handle-keyed script-data map.
1504	2542	*
1505		- * @return array[]
	2543	+ * For each entry registered via `openstation_register_window()` the
	2544	+ * `windows` list captures the window's metadata
	2545	+ * (id/title/icon/placement/dimensions/autofocus), the rendered
	2546	+ * template HTML, and the HANDLE NAMES of its script, companions and
	2547	+ * tab scripts. The resolved data those handles stand for — URL plus
	2548	+ * harvested `wp_localize_script` / `wp_add_inline_script` /
	2549	+ * translations, see `openstation_resolve_script_payload()` — lives
	2550	+ * ONCE per handle in `scriptData`, and the shell joins the two on
	2551	+ * receipt (`hydrateServerEntries()` in `src/native-windows.ts`).
	2552	+ * Each loadable handle's entry also names its dependency closure in
	2553	+ * `deps` (ordered handles, every one of them a key of the same map)
	2554	+ * so the lazy loader can bring a bundle's declared packages — and
	2555	+ * a src-less alias carrying its config — into the tab before it.
	2556	+ *
	2557	+ * The split exists because script data is a property of the HANDLE,
	2558	+ * not of the window: every App Framework window rides
	2559	+ * `openstation-app-runtime`, and inlining each entry's resolved copy
	2560	+ * serialized the same localize blobs and the same shared config set
	2561	+ * four times over — `scriptL10n` alone was ~100 KB of the boot
	2562	+ * payload, most of it repetition. The synthesized
	2563	+ * `openStationWindowConfig[ id ]` assignments group by handle for
	2564	+ * the same reason they used to ride every sharing entry: the shell
	2565	+ * fetches a URL once, and a bundle can serve one window from inside
	2566	+ * another (the Users window mounts the Profile form, which reads the
	2567	+ * user-edit config), so whichever entry loads the bundle must
	2568	+ * deliver the whole handle's config set.
	2569	+ *
	2570	+ * Style data stays inline on the entries — it never had a
	2571	+ * duplication problem worth a second map ( companion styles across
	2572	+ * the whole registry total ~2 KB ).
	2573	+ *
	2574	+ * @return array{windows:array[],scriptData:array<string,array{url:string,before:string[],after:string[],l10n:string[],translations:string,deps:string[]}>}
1506	2575	*/
1507		-function desktop_mode_build_native_windows_payload() {
1508		- if ( ! function_exists( 'desktop_mode_native_window_registry' ) ) {
1509		- return array();
	2576	+function openstation_collect_native_windows_payload() {
	2577	+ $empty = array(
	2578	+ 'windows' => array(),
	2579	+ 'scriptData' => array(),
	2580	+ );
	2581	+ if ( ! function_exists( 'openstation_native_window_registry' ) ) {
	2582	+ return $empty;
1510	2583	}
1511		- $registry = desktop_mode_native_window_registry();
	2584	+
	2585	+ $registry = openstation_native_window_registry();
1512	2586	if ( ! is_array( $registry ) ) {
1513		- return array();
	2587	+ return $empty;
1514	2588	}
1515	2589
	2590	+ // A window says which admin offers it (`admin` in its registration:
	2591	+ // `site`, `network` or `any`). Every native window OpenStation
	2592	+ // ships is site-scoped, reading the current site's REST API, so in
	2593	+ // the network admin a `users.php` tile meaning "everyone on the
	2594	+ // network" would open one site's user list; those stay off the
	2595	+ // network shell. A window that declares `network` (the Network app)
	2596	+ // is offered there and nowhere else.
	2597	+ //
	2598	+ // Dropping the site windows there is also what disarms the
	2599	+ // client-side URL remaps: they match on the tail of a pathname
	2600	+ // (`endsWith( '/users.php' )`) and the network admin serves
	2601	+ // same-named files one directory down, but with nothing registered
	2602	+ // `openById()` finds no window and the remap falls through to the
	2603	+ // iframe.
	2604	+ $registry = array_filter( $registry, 'openstation_native_window_offered_here' );
	2605	+
	2606	+ $script_data = array();
	2607	+
	2608	+ // Handles resolved as a bundle to LOAD (a window's script, a
	2609	+ // companion, a tab) and what that visit answered — the handle, or
	2610	+ // '' for nothing to load — as opposed to reached only as
	2611	+ // somebody's dependency. A handle can be both — resolved as a
	2612	+ // dependency first, then named as a window's own script — and
	2613	+ // only the bundle visit computes its own closure.
	2614	+ $resolved_as_bundle = array();
	2615	+
	2616	+ // Resolve a handle into the map, once. Returns the handle when it
	2617	+ // resolved to something loadable, '' when it did not (never
	2618	+ // registered, no src) — the same silent drop the inline shape
	2619	+ // applied to companions and tab scripts.
	2620	+ //
	2621	+ // The handle's dependency closure rides along as `deps`: an
	2622	+ // ordered handle list, each of which lands in the same map. A
	2623	+ // bundle delivered lazily never goes through WordPress's own
	2624	+ // dependency resolution — the loader injects one URL — so a
	2625	+ // window declaring `wp-api-fetch` found `wp.apiFetch` undefined,
	2626	+ // and one whose config rides a src-less alias handle (a common
	2627	+ // shape: `wp_register_script( $h, false )` plus
	2628	+ // `wp_add_inline_script()`, declared as the bundle's dependency
	2629	+ // so it always runs first) booted with no config at all. Anything
	2630	+ // the document already ran is skipped on the client, so a page
	2631	+ // that carried the packages anyway pays nothing.
	2632	+ $collect_handle = static function ( $handle ) use ( &$script_data, &$resolved_as_bundle ) {
	2633	+ $handle = (string) $handle;
	2634	+ if ( '' === $handle ) {
	2635	+ return '';
	2636	+ }
	2637	+ if ( isset( $resolved_as_bundle[ $handle ] ) ) {
	2638	+ return $resolved_as_bundle[ $handle ];
	2639	+ }
	2640	+ $payload = isset( $script_data[ $handle ] )
	2641	+ ? $script_data[ $handle ]
	2642	+ : openstation_resolve_script_payload( $handle );
	2643	+ if ( '' === $payload['url'] ) {
	2644	+ $resolved_as_bundle[ $handle ] = '';
	2645	+ return '';
	2646	+ }
	2647	+ $resolved_as_bundle[ $handle ] = $handle;
	2648	+ $deps = array();
	2649	+ foreach ( openstation_resolve_script_dependencies( $handle ) as $dep ) {
	2650	+ $dep_handle = (string) $dep['handle'];
	2651	+ unset( $dep['handle'] );
	2652	+ if ( ! isset( $script_data[ $dep_handle ] ) ) {
	2653	+ $dep['deps'] = array();
	2654	+ $script_data[ $dep_handle ] = $dep;
	2655	+ }
	2656	+ $deps[] = $dep_handle;
	2657	+ }
	2658	+ $payload['deps'] = $deps;
	2659	+ $script_data[ $handle ] = $payload;
	2660	+ return $handle;
	2661	+ };
	2662	+
	2663	+ // Synthesized `openStationWindowConfig[ id ]` assignments, grouped
	2664	+ // by script handle (see the function docblock). Collected first so
	2665	+ // they can be appended to each handle's map entry exactly once,
	2666	+ // after its own harvested data — the same order the print pipeline
	2667	+ // would have used.
	2668	+ $config_snippets_by_handle = array();
	2669	+ foreach ( $registry as $entry ) {
	2670	+ $handle = isset( $entry['script'] ) ? (string) $entry['script'] : '';
	2671	+ if ( '' === $handle || ! is_callable( $entry['template'] ) ) {
	2672	+ continue;
	2673	+ }
	2674	+ $window_config = openstation_filter_native_window_config( $entry );
	2675	+ if ( empty( $window_config ) ) {
	2676	+ continue;
	2677	+ }
	2678	+ $config_snippets_by_handle[ $handle ][ $entry['id'] ] = sprintf(
	2679	+ 'window.openStationWindowConfig=window.openStationWindowConfig||{};window.openStationWindowConfig[%s]=%s;',
	2680	+ wp_json_encode( $entry['id'] ),
	2681	+ wp_json_encode( $window_config )
	2682	+ );
	2683	+ }
	2684	+
1516	2685	$out = array();
1517	2686	foreach ( $registry as $entry ) {
1518	2687	if ( ! is_callable( $entry['template'] ) ) {
1519	2688	continue;
		@@ -1520,23 +2689,43 @@
1520	2689	}
1521	2690
1522	2691	// Capture the template HTML (tab-wrapped when any
1523	2692	// additional tabs are registered via
1524		- // `desktop_mode_register_window_tab()`; flat otherwise).
	2693	+ // `openstation_register_window_tab()`; flat otherwise).
1525	2694	// Captured as a string so the shell can inject it as a
1526	2695	// `<template>` at mid-session plugin activation without a
1527	2696	// reload.
1528		- $template_html = desktop_mode_build_native_window_template_html( $entry );
	2697	+ $template_html = openstation_build_native_window_template_html( $entry );
1529	2698
1530		- // Resolve script handle → full payload (URL + harvested
1531		- // `extra` data) so the shell can inject a `<script>` tag
1532		- // dynamically on mid-session activation WITHOUT dropping
1533		- // `wp_localize_script` / `wp_add_inline_script` data the way
1534		- // the bare `<script src>` lazy-load path would. See
1535		- // `desktop_mode_resolve_script_payload()` for shape.
1536		- $script_handle = isset( $entry['script'] ) ? (string) $entry['script'] : '';
1537		- $script_payload = desktop_mode_resolve_script_payload( $script_handle );
	2699	+ // `$collect_handle()` answers "is there a bundle to fetch?", and
	2700	+ // returns '' when the handle resolves to no URL — a src-less
	2701	+ // alias handle registered only to carry `preload_script` or
	2702	+ // inline data, for instance. That is the right answer for
	2703	+ // `scriptHandle`, which names something to load. It is the
	2704	+ // wrong answer for `ownerHandle`, which names WHO the window
	2705	+ // belongs to: attribution does not depend on whether the owner
	2706	+ // happens to ship a file. Shipping '' there broke the
	2707	+ // documented "always populated" contract and blanked
	2708	+ // `wp.os.debug.window()`.
	2709	+ $declared_script = isset( $entry['script'] ) ? (string) $entry['script'] : '';
	2710	+ $script_handle = $collect_handle( $declared_script );
	2711	+ $owner_handle = '' !== $script_handle ? $script_handle : $declared_script;
1538	2712
	2713	+ // Companion handles (`scripts` arg) — bundles that extend the
	2714	+ // window from outside it and must be in the tab before its
	2715	+ // render callback paints. Kept as an ordered handle list; the
	2716	+ // shell loads them in declared order ahead of the window's
	2717	+ // own script, resolving each through `scriptData`.
	2718	+ $companion_scripts = array();
	2719	+ if ( ! empty( $entry['scripts'] ) && is_array( $entry['scripts'] ) ) {
	2720	+ foreach ( $entry['scripts'] as $companion_handle ) {
	2721	+ $companion_handle = $collect_handle( $companion_handle );
	2722	+ if ( '' !== $companion_handle ) {
	2723	+ $companion_scripts[] = $companion_handle;
	2724	+ }
	2725	+ }
	2726	+ }
	2727	+
1539	2728	// Resolve the optional style handle alongside the script so the
1540	2729	// shell's lazy-loader can inject a `<link rel="stylesheet">`
1541	2730	// (and any `wp_add_inline_style()` blobs) on mid-session
1542	2731	// activation. Empty payload when no handle was declared OR the
		@@ -1541,77 +2730,149 @@
1541	2730	// (and any `wp_add_inline_style()` blobs) on mid-session
1542	2731	// activation. Empty payload when no handle was declared OR the
1543	2732	// handle isn't registered — both treated as "no styles to load."
1544	2733	$style_handle = isset( $entry['style'] ) ? (string) $entry['style'] : '';
1545		- $style_payload = desktop_mode_resolve_style_payload( $style_handle );
	2734	+ $style_payload = openstation_resolve_style_payload( $style_handle );
1546	2735
1547		- // `config` arg on `desktop_mode_register_window()` — discoverable
1548		- // alternative to `wp_localize_script`. We synthesize a localize
1549		- // snippet so it lands through the same delivery path as native
1550		- // `wp_localize_script`. The bundle reads
1551		- // `window.desktopModeWindowConfig[id]` (or via
1552		- // `wp.desktop.getWindowConfig(id)`).
1553		- if ( ! empty( $entry['config'] ) && is_array( $entry['config'] ) ) {
1554		- $script_payload['l10n'][] = sprintf(
1555		- 'window.desktopModeWindowConfig=window.desktopModeWindowConfig||{};window.desktopModeWindowConfig[%s]=%s;',
1556		- wp_json_encode( $entry['id'] ),
1557		- wp_json_encode( $entry['config'] )
1558		- );
	2736	+ // Companion style handles (`styles` arg) — stylesheets the
	2737	+ // shell injects on the window's FIRST OPEN, after the window's
	2738	+ // own style, in declared order. The styles-side mirror of
	2739	+ // `companionScripts`, with different timing on purpose: the
	2740	+ // window's own `style` lands when the window registers so a
	2741	+ // mid-session activation paints, but a companion exists to be
	2742	+ // deferred — it costs nothing until the window is actually
	2743	+ // shown. Unregistered handles drop, same as script companions.
	2744	+ $companion_styles = array();
	2745	+ if ( ! empty( $entry['styles'] ) && is_array( $entry['styles'] ) ) {
	2746	+ foreach ( $entry['styles'] as $companion_style_handle ) {
	2747	+ $companion_style_handle = (string) $companion_style_handle;
	2748	+ $companion_style_payload = openstation_resolve_style_payload( $companion_style_handle );
	2749	+ if ( '' === $companion_style_payload['url'] ) {
	2750	+ continue;
	2751	+ }
	2752	+ $companion_styles[] = array(
	2753	+ 'styleUrl' => $companion_style_payload['url'],
	2754	+ 'styleHandle' => $companion_style_handle,
	2755	+ 'styleInline' => $companion_style_payload['inline'],
	2756	+ );
	2757	+ }
1559	2758	}
1560	2759
1561		- // Tab metadata (label + extra script payloads) ships alongside
1562		- // the template so the shell can render a picker UI or load
1563		- // additional tab scripts when a tab's activation is late.
	2760	+ // Tab metadata ships alongside the template so the shell can
	2761	+ // render a picker UI, and each tab's script handle joins the
	2762	+ // map so a late tab activation can still load its bundle.
1564	2763	$tab_descriptors = array();
1565		- if ( function_exists( 'desktop_mode_get_native_window_tabs' ) ) {
1566		- foreach ( desktop_mode_get_native_window_tabs( $entry['id'] ) as $tab ) {
1567		- // The resolver returns the empty payload shape itself
1568		- // for an empty handle — no need to hand-write it here.
1569		- $tab_payload = desktop_mode_resolve_script_payload( $tab['script'] );
	2764	+ if ( function_exists( 'openstation_get_native_window_tabs' ) ) {
	2765	+ foreach ( openstation_get_native_window_tabs( $entry['id'] ) as $tab ) {
1570	2766	$tab_descriptors[] = array(
1571		- 'value' => $tab['value'],
1572		- 'label' => $tab['label'],
1573		- 'isMain' => $tab['is_main'],
1574		- 'scriptUrl' => $tab_payload['url'],
1575		- 'scriptHandle' => $tab['script'],
1576		- 'scriptBefore' => $tab_payload['before'],
1577		- 'scriptAfter' => $tab_payload['after'],
1578		- 'scriptL10n' => $tab_payload['l10n'],
1579		- 'scriptTranslations' => $tab_payload['translations'],
	2767	+ 'value' => $tab['value'],
	2768	+ 'label' => $tab['label'],
	2769	+ 'isMain' => $tab['is_main'],
	2770	+ 'scriptHandle' => $collect_handle( $tab['script'] ),
1580	2771	);
1581	2772	}
1582	2773	}
1583	2774
1584	2775	$out[] = array(
1585		- 'id' => $entry['id'],
1586		- 'title' => $entry['title'],
1587		- 'icon' => $entry['icon'],
1588		- 'placement' => $entry['placement'],
1589		- 'width' => $entry['width'],
1590		- 'height' => $entry['height'],
1591		- 'minWidth' => $entry['min_width'],
1592		- 'minHeight' => $entry['min_height'],
1593		- 'autofocus' => $entry['autofocus'],
1594		- 'templateId' => 'desktop-mode-native-window-' . $entry['id'],
1595		- 'templateHtml' => $template_html,
1596		- 'scriptUrl' => $script_payload['url'],
1597		- 'scriptHandle' => $script_handle,
1598		- 'ownerHandle' => $script_handle,
1599		- 'scriptBefore' => $script_payload['before'],
1600		- 'scriptAfter' => $script_payload['after'],
1601		- 'scriptL10n' => $script_payload['l10n'],
1602		- 'scriptTranslations' => $script_payload['translations'],
1603		- 'styleUrl' => $style_payload['url'],
1604		- 'styleHandle' => $style_handle,
1605		- 'styleInline' => $style_payload['inline'],
1606		- 'tabs' => $tab_descriptors,
	2776	+ 'id' => $entry['id'],
	2777	+ 'title' => $entry['title'],
	2778	+ 'icon' => $entry['icon'],
	2779	+ 'placement' => $entry['placement'],
	2780	+ // `'app'` or `'control'` — the navigation kind, which
	2781	+ // decides the launcher's default placement and its dock
	2782	+ // zone. See `src/nav/defaults.ts`.
	2783	+ 'navKind' => isset( $entry['nav_kind'] ) ? $entry['nav_kind'] : 'app',
	2784	+ // Sort key among system tiles. Absent / 0 puts a plugin's
	2785	+ // launcher ahead of the shell's own trailing cluster.
	2786	+ 'dockOrder' => isset( $entry['dock_order'] ) ? (int) $entry['dock_order'] : 0,
	2787	+ 'placeable' => ! empty( $entry['placeable'] ),
	2788	+ 'width' => $entry['width'],
	2789	+ 'height' => $entry['height'],
	2790	+ 'minWidth' => $entry['min_width'],
	2791	+ 'minHeight' => $entry['min_height'],
	2792	+ 'autofocus' => $entry['autofocus'],
	2793	+ 'templateId' => 'os-native-window-' . $entry['id'],
	2794	+ 'templateHtml' => $template_html,
	2795	+ 'scriptHandle' => $script_handle,
	2796	+ 'ownerHandle' => $owner_handle,
	2797	+ 'companionScripts' => $companion_scripts,
	2798	+ // Whether the shell loads the bundle at boot rather than on
	2799	+ // first open. Off by default: a window's script is dead
	2800	+ // weight on every admin page until the window is actually
	2801	+ // opened.
	2802	+ 'preloadScript' => ! empty( $entry['preload_script'] ),
	2803	+ 'styleUrl' => $style_payload['url'],
	2804	+ 'styleHandle' => $style_handle,
	2805	+ 'styleInline' => $style_payload['inline'],
	2806	+ 'companionStyles' => $companion_styles,
	2807	+ 'tabs' => $tab_descriptors,
	2808	+ 'menuPages' => isset( $entry['menu_pages'] ) ? array_values( (array) $entry['menu_pages'] ) : array(),
1607	2809	);
1608	2810	}
1609	2811
1610		- return $out;
	2812	+ // Append each handle's synthesized config set to its map entry —
	2813	+ // once, after the handle's own harvested data. The snippets land
	2814	+ // in REGISTRY-ITERATION order for every consumer of the handle;
	2815	+ // the old per-entry shape put each window's own config first, an
	2816	+ // ordering nothing could observe (each snippet assigns a distinct
	2817	+ // `openStationWindowConfig[ id ]` key and none reads another), so
	2818	+ // it is deliberately not preserved. Configs for handles that
	2819	+ // resolved to nothing are undeliverable and drop, exactly as they
	2820	+ // always did.
	2821	+ foreach ( $config_snippets_by_handle as $handle => $snippets ) {
	2822	+ if ( ! isset( $script_data[ $handle ] ) ) {
	2823	+ continue;
	2824	+ }
	2825	+ foreach ( $snippets as $snippet ) {
	2826	+ $script_data[ $handle ]['l10n'][] = $snippet;
	2827	+ }
	2828	+ }
	2829	+
	2830	+ return array(
	2831	+ 'windows' => $out,
	2832	+ 'scriptData' => $script_data,
	2833	+ );
1611	2834	}
1612	2835
1613	2836	/**
	2837	+ * The `windows` half of {@see openstation_collect_native_windows_payload()}.
	2838	+ *
	2839	+ * Kept as the historical entry point — tests and older call sites
	2840	+ * ask for the entry list alone. Anything that also needs the
	2841	+ * script-data map (everything that actually LOADS a bundle) should
	2842	+ * call the collector and take both halves from one build.
	2843	+ *
	2844	+ * @return array[]
	2845	+ */
	2846	+function openstation_build_native_windows_payload() {
	2847	+ $bundle = openstation_collect_native_windows_payload();
	2848	+ return $bundle['windows'];
	2849	+}
	2850	+
	2851	+/**
	2852	+ * Cleans a `$menu` / `$submenu` title for display.
	2853	+ *
	2854	+ * Strips badge spans first (`<span class="update-plugins count-3">`),
	2855	+ * then any remaining markup. An empty result means the entry has no
	2856	+ * usable label: plugins register `menu_title => null` to keep a page
	2857	+ * reachable while hiding its row from classic admin's left menu, and
	2858	+ * those must not become tabs.
	2859	+ *
	2860	+ * Shared so everything deciding "is this a visible tab?" agrees.
	2861	+ * {@see openstation_chromeless_submenu_tab_urls()} hides an in-page
	2862	+ * button on the strength of a tab existing, so a divergence here would
	2863	+ * hide a button with nothing on screen to replace it.
	2864	+ *
	2865	+ * @param string $raw_title Raw `$menu[$i][0]` / `$submenu[$p][$i][0]` value.
	2866	+ * @return string Cleaned title, empty when there is none.
	2867	+ */
	2868	+function openstation_menu_item_title( $raw_title ) {
	2869	+ $stripped = preg_replace( '/<span[^>]*>.*?<\/span>/s', '', (string) $raw_title );
	2870	+
	2871	+ return trim( wp_strip_all_tags( $stripped ) );
	2872	+}
	2873	+
	2874	+/**
1614	2875	* Determines whether a menu slug references a real file under `wp-admin/`.
1615	2876	*
1616	2877	* Mirrors the decision core's `wp-admin/menu-header.php` makes when
1617	2878	* linking menu items: strip the query portion, then check whether the
		@@ -1631,9 +2892,9 @@
1631	2892	*
1632	2893	* @param string $slug The raw menu item slug.
1633	2894	* @return bool True when the query-stripped slug is a file under `wp-admin/`.
1634	2895	*/
1635		-function desktop_mode_is_admin_file_slug( $slug ) {
	2896	+function openstation_is_admin_file_slug( $slug ) {
1636	2897	$file = $slug;
1637	2898	$pos = strpos( $file, '?' );
1638	2899	if ( false !== $pos ) {
1639	2900	$file = substr( $file, 0, $pos );
		@@ -1646,13 +2907,45 @@
1646	2907	return file_exists( ABSPATH . 'wp-admin/' . $file );
1647	2908	}
1648	2909
1649	2910	/**
	2911	+ * The admin URL a menu slug resolves against.
	2912	+ *
	2913	+ * Follows the admin the request is in: the network admin's own URL there,
	2914	+ * because its globals carry network slugs (`sites.php`, `settings.php`)
	2915	+ * that exist only under `wp-admin/network/`, and the site admin's
	2916	+ * everywhere else.
	2917	+ *
	2918	+ * The same answer `self_admin_url()` gives, without its filter. That
	2919	+ * filter receives the path, so a host can use it to send one screen
	2920	+ * somewhere else, and WordPress.com points `plugin-install.php` at its own
	2921	+ * installer. Resolved through it, the wp-admin original of a menu row the
	2922	+ * host replaced reads as off-site, and the dock drops it along with the
	2923	+ * replacement, which is how Plugins > Add Plugin disappears there.
	2924	+ *
	2925	+ * @param string $path Optional. Path relative to the admin URL.
	2926	+ * @return string Absolute admin URL.
	2927	+ */
	2928	+function openstation_menu_admin_url( $path = '' ) {
	2929	+ if ( is_network_admin() ) {
	2930	+ return network_admin_url( $path );
	2931	+ }
	2932	+ if ( is_user_admin() ) {
	2933	+ return user_admin_url( $path );
	2934	+ }
	2935	+ return admin_url( $path );
	2936	+}
	2937	+
	2938	+/**
1650	2939	* Converts a menu item slug to a full admin URL.
1651	2940	*
	2941	+ * Resolution goes through {@see openstation_menu_admin_url()}, which
	2942	+ * follows the admin the request is in without passing through the
	2943	+ * filterable `self_admin_url()`.
	2944	+ *
1652	2945	* Handles three slug shapes:
1653	2946	* 1. Direct file references (`edit.php`, `upload.php`) — passed
1654		- * through `admin_url()` as-is.
	2947	+ * through `openstation_menu_admin_url()` as-is.
1655	2948	* 2. Plain plugin page slugs (`my-plugin`) — routed through
1656	2949	* `admin.php?page=<slug>` with the slug `rawurlencode()`d.
1657	2950	* 3. Plugin page slugs that embed extra query parameters
1658	2951	* (`wc-admin&path=/customers`) — split on the first `&`, the
		@@ -1680,9 +2973,9 @@
1680	2973	*
1681	2974	* @param string $slug The menu item slug or URL.
1682	2975	* @return string The full admin URL, sanitized via `esc_url_raw()`.
1683	2976	*/
1684		-function desktop_mode_menu_item_url( $slug ) {
	2977	+function openstation_menu_item_url( $slug ) {
1685	2978	// Already a full URL.
1686	2979	if ( str_starts_with( $slug, 'http://' ) || str_starts_with( $slug, 'https://' ) ) {
1687	2980	return esc_url_raw( $slug );
1688	2981	}
		@@ -1711,11 +3004,11 @@
1711	3004	// file check wins over the registration check, same as classic
1712	3005	// admin's `menu-header.php`.
1713	3006	if (
1714	3007	false !== strpos( $slug, '.php' ) &&
1715		- ( ! isset( $_parent_pages[ $slug ] ) || desktop_mode_is_admin_file_slug( $slug ) )
	3008	+ ( ! isset( $_parent_pages[ $slug ] ) || openstation_is_admin_file_slug( $slug ) )
1716	3009	) {
1717		- return esc_url_raw( admin_url( $slug ) );
	3010	+ return esc_url_raw( openstation_menu_admin_url( $slug ) );
1718	3011	}
1719	3012
1720	3013	// Plugin page slug with embedded query parameters
1721	3014	// (e.g., 'wc-admin&path=/customers'). Split the page slug from
		@@ -1739,16 +3032,16 @@
1739	3032	// `&` separators we need to keep raw for the downstream
1740	3033	// `add_query_arg()` and the JS slug compare).
1741	3034	//
1742	3035	// Resolution rules, identical to core:
1743		- // 1. Slug registered under a `.php` parent that itself isn't
1744		- // a parent (Tools → `tools.php?page=…`, Settings →
1745		- // `options-general.php?page=…`).
1746		- // 2. Slug registered as a top-level menu, OR under a slug-
1747		- // based parent (WC: `woocommerce` → `admin.php?page=…`).
1748		- // 3. Slug not registered at all → fall back to `admin.php`
1749		- // so the URL still targets a real dispatcher (matches the
1750		- // pre-resolver behavior callers depended on).
	3036	+ // 1. Slug registered under a `.php` parent that itself isn't
	3037	+ // a parent (Tools → `tools.php?page=…`, Settings →
	3038	+ // `options-general.php?page=…`).
	3039	+ // 2. Slug registered as a top-level menu, OR under a slug-
	3040	+ // based parent (WC: `woocommerce` → `admin.php?page=…`).
	3041	+ // 3. Slug not registered at all → fall back to `admin.php`
	3042	+ // so the URL still targets a real dispatcher (matches the
	3043	+ // pre-resolver behavior callers depended on).
1751	3044	$host = 'admin.php?page=' . rawurlencode( $slug );
1752	3045	if ( isset( $_parent_pages[ $slug ] ) ) {
1753	3046	$parent_slug = $_parent_pages[ $slug ];
1754	3047	if ( $parent_slug && ! isset( $_parent_pages[ $parent_slug ] ) ) {
		@@ -1755,9 +3048,9 @@
1755	3048	$host = add_query_arg( 'page', $slug, $parent_slug );
1756	3049	}
1757	3050	}
1758	3051
1759		- $url = admin_url( $host );
	3052	+ $url = openstation_menu_admin_url( $host );
1760	3053	if ( ! empty( $extra_args ) ) {
1761	3054	$url = add_query_arg( $extra_args, $url );
1762	3055	}
1763	3056	return esc_url_raw( $url );