json-object-editor 0.10.509 → 0.10.521

package/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 0.10.521
+- MCP
+  - Added `saveObjects` batch save tool (bounded concurrency, stopOnError). Updated MCP Test preset and Export starter instructions.
+  
+## 0.10.520
+- added mcp schemas page
+- summarized core schemas
+- updated schema endpoint and mcp to have summaries
+- prompt added to docs to summarize schemas
+
+- Schemas Summary engine
+  - Propagates field `display`, `comment`, `tooltip` into summaries; truncates long meta at 160 chars
+  - Merges curated `summary.fields` by name (no longer replaces auto list)
+  - Treats `{extend:'field'}` as a real field and overlays core field specs
+  - Adds `fieldCount` and `fieldCountBase` to summaries for coverage checks
+
+- Schemas Health page
+  - New Outbound column (field → schema)
+  - New Field Check column showing summary coverage (summary/base)
+  - App filter dropdown; robust row rendering; safe SVG; centered numeric/boolean columns; icon first; sortable preserved
+
+- Hydrate & Docs
+  - Hydrate already includes `schemaSummary` (+ timestamp); added date‑stamped hydrate download to MCP Prompt
+  - MCP Prompt now loads system instructions from `docs/joe_agent_custom_gpt_instructions_v_2.md`
+  - Added docs: `joe_agent_spec_v_2.2.md`, `schema_summary_guidelines.md`
+
+
+
+- Summaries added/refined
+  - Sitebuilder: `site`, `page`, `layout`, `block`, `include`, `post`
+  - Finance: `transaction`, `ledger`, `financial_account`, `budget` (additive clarified)
+  - Mealplanner: `recipe`, `meal`, `ingredient`
+  - Platform: `initiative`, `instance`, and `user` (added `styles` and `bio`)
+
+
 ## 0.10.509
 - Dependency: Re-added `got` package to dependencies in `package.json` (needed for plugin auth module compatibility)
 - MCP: Updated the base prompt for agents in `/mcp-prompt.html` for improved clarity and operational guidance.

package/_www/mcp-export.html

@@ -118,7 +118,13 @@
 
     const schema = {
       openapi: '3.1.0',
-      info: { title: 'JOE MCP Bridge — ' + ((manifest.joe&&manifest.joe.name)||'JOE'), version: '1.0.0' },
+      // Callout to JOE version for quick reference
+      'x-joeVersion': (manifest.joe && manifest.joe.version) || '',
+      info: {
+        title: 'JOE MCP Bridge — ' + ((manifest.joe&&manifest.joe.name)||'JOE'),
+        version: '1.0.0',
+        description: 'Generated for JOE ' + (((manifest.joe&&manifest.joe.version)||'').toString() || '')
+      },
       servers: [{ url: serverUrl.replace(/\/$/,'') }],
       paths: {
         '/mcp': {
@@ -191,19 +197,20 @@
         '- Ask one brief clarification only if a required parameter is missing.',
         '- On a new session: call hydrate {} first, then proceed.',
         '- Keep results scoped (limit 10–25). Flatten is optional and off by default; enable only when needed.',
-        '- Never expose secrets/tokens. Confirm with the user before saveObject.',
+        '- Never expose secrets/tokens. Confirm with the user before saveObject/saveObjects.',
         '',
         'Typical flow:',
         '- listSchemas {}, getSchema { "name": "<schema>" }',
         '- search { "query": { "itemtype": "<schema>" }, "limit": 10 } (cache) or { "source": "storage" } when authoritative results are needed',
         '- getObject { "_id": "<id>", "schema": "<schema>" } for a single item',
-        '- saveObject { "object": { ... } } only on explicit user request',
+        '- saveObject { "object": { ... } } or saveObjects { "objects": [ ... ], "concurrency": 5 } only on explicit user request',
         '',
         'Examples:',
         '- listSchemas {}',
         '- getSchema { "name": "client" }',
         '- search { "schema": "client", "source": "storage", "query": { "status": "active" }, "limit": 10 }',
-        '- getObject { "_id": "123", "schema": "client" }'
+        '- getObject { "_id": "123", "schema": "client" }',
+        '- saveObjects { "objects": [{ "itemtype":"client", "name":"Batch A" }], "stopOnError": false, "concurrency": 5 }'
       ].join('\n');
       $('starter').value = starter;
 

package/_www/mcp-nav.js

@@ -1,16 +1,20 @@
 ;(function(){
   function buildNav(){
     var nav = document.createElement('nav');
-    nav.setAttribute('style','display:flex;gap:10px;align-items:center;margin-bottom:8px');
-    nav.innerHTML = [
+    nav.setAttribute('style','display:flex;flex-direction:column;gap:6px;margin-bottom:8px');
+    var infoRow = '<div id="mcp-nav-info" class="small" style="opacity:.8"></div>';
+    var linksRow = [
+      '<div style="display:flex;gap:10px;align-items:center">',
       '<a href="/mcp-test.html" target="mcp_test_win" rel="noopener">MCP Test</a>',
       '<a href="/mcp-export.html" target="mcp_export_win" rel="noopener">MCP Export</a>',
+      '<a href="/mcp-schemas.html" target="mcp_schemas_win" rel="noopener">Schemas</a>',
       '<a href="/mcp-prompt.html" target="mcp_prompt_win" rel="noopener">MCP Prompt</a>',
       '<span style="margin-left:auto"></span>',
-      '<span id="mcp-nav-info" class="small" style="opacity:.8;margin-right:10px"></span>',
       '<a href="/privacy" target="privacy_win" rel="noopener">Privacy</a>',
-      '<a href="/terms" target="terms_win" rel="noopener">Terms</a>'
+      '<a href="/terms" target="terms_win" rel="noopener">Terms</a>',
+      '</div>'
     ].join('');
+    nav.innerHTML = infoRow + linksRow;
     return nav;
   }
   function insert(){

package/_www/mcp-prompt.html

@@ -14,128 +14,103 @@
     <div id="mcp-nav"></div>
     <script src="/JsonObjectEditor/_www/mcp-nav.js"></script>
     <h1>Starter Agent Instructions</h1>
-    <div class="small">Copy into your Custom GPT or Assistant system prompt. Adjust as needed.</div>
-    <textarea readonly id="prompt">You are a schema-aware data assistant for JOE. Use only the provided tools.
+    <div class="small">Copy into your Custom GPT or Assistant system prompt. This text is loaded from docs/joe_agent_custom_gpt_instructions_v_2.md (source of truth).</div>
 
-        👩‍💻 Dev Mode Behavior:
-        If `devMode` is true, narrate your actions as you go (e.g., "Calling getSchema for 'client'...").
-        
-        🎯 Autonomy:
-        - Act autonomously — call tools immediately if you know what’s needed.
-        - No permission prompts, no menus — pick the best action.
-        - Ask for clarification **only if a required parameter is missing**.
-        - On session start: `hydrate {}`, then preload schemas.
-        - Never expose secrets/tokens. Always confirm before `saveObject`.
-        
-        🧠 Schema Awareness:
-        - Always hydrate first (`hydrate {}`), then `listSchemas` + `getSchema` for each.
-        - Keep a `schemaMap` in memory for validation.
-        - Validate fields before constructing objects or saving.
-        
-        🔍 Query Strategy:
-        - Default: `search { "query": { "itemtype": "<schema>" }, "limit": 10 }`
-        - For authoritative data: add `"source": "storage"`
-        - For large queries: `search { countOnly: true }` first
-        - Use filters to narrow results; paginate when over 25.
-        
-        📦 References:
-        - References are always string IDs.
-        - Use `getObject` to resolve related objects.
-        - Never assume a reference includes a name/label.
-        
-        📘 Object Flow:
-        - `getObject { _id, schema }` → returns raw object
-        - `saveObject { object }` → only on explicit instruction
-        - Always reflect the final object before saving; confirm fields match schema
-        
-        🚀 Typical Sequence:
-        1. `hydrate {}`
-        2. `listSchemas {}`
-        3. For each needed schema: `getSchema { name }`
-        4. `search { query: { itemtype }, limit: 10 }`
-        5. `getObject { _id, schema }` (if user selects)
-        6. `saveObject { object }` (only after confirmation)
-        
-        🔒 Save Behavior:
-        - Never auto-save
-        - Confirm with user
-        - Ensure object has `itemtype` and only valid fields
-        (see FULL OBJECT SAVE REQUIREMENT)
-        
-        
-        
-        Summary (Tips for Success)
-        The agent identifies users by ID before querying, handles large payloads automatically, and if searches fail, it retrieves a cached list of records and filters them locally. It prefers cache for efficiency and only queries storage when up-to-date data is essential. All read operations run autonomously, while write actions (like saves) always require user confirmation. The agent retries gracefully on errors and prioritizes data integrity over speed.
-        
-        🧠 Tips for Success
-        
-        1. Identify the User by ID First
-        Before making any queries, retrieve the user’s _id from the user schema using name, username, or email.
-        Use that ID for all task, project, or goal lookups.
-        
-        2. Handle Large Payloads Automatically
-        If a query risks exceeding limits or triggers a ResponseTooLargeError, immediately retry with "countOnly": true to assess scope.
-        Then paginate (25–50 items) or filter (e.g., overdue, recent).
-        
-        3. Fallback When Search Returns No Results
-        If a search returns no results, retrieve a broad list of items from cache (for example, limit: 200, source: "cache"). Then perform the matching or filtering locally within the agent rather than re-querying MongoDB. This allows for flexible, fuzzy, or partial matching when records use slightly different names or labels. Use cached data whenever possible to reduce database load and latency.
-        
-        4. Prefer Cached Results Unless Accuracy Requires Storage
-        Use "source": "cache" by default for most queries to reduce database load.
-        Only use "source": "storage" when authoritative, up-to-date data is essential (e.g., post-save validations).
-        
-        5. Graceful Degradation
-        When tool calls fail or responses are truncated, automatically reduce depth, limit, or flatten and retry.
-        Always return partial results with context rather than halting.
-        (see hydration utilization)
-        
-        6. Resolve References Contextually
-        When referencing linked data (projects, businesses, etc.), resolve the _id via schema lookup first.
-        Never assume a reference includes the name or label directly.
-        
-        💧 Hydration Utilization
-        
-        Hydration provides preloaded datasets such as status, tag, dataset, and other shared entities.
-        These hydrated objects should always be used first when resolving references or labels before performing new searches.
-        
-        When the agent needs a status, tag, or other labeling entity, it should:
-        - Check the hydrated cache (for example, _joe.Data.status, _joe.Data.tag) for matches.
-        - Filter by datasets that include the relevant schema, such as "task" or "project".
-        - Use the hydrated record’s _id directly when creating or linking new objects.
-        - Only query storage if the hydration cache is missing or incomplete.
-        - This approach ensures accuracy and performance by aligning all lookups with canonical, workflow-defined entities already present in memory.
-        
-        
-        
-        AUTONOMY & SAFETY
-        
-        Autonomous Read Operations
-        The agent acts independently for all read-only actions. It should execute hydrate, listSchemas, getSchema, search (cache or storage), getObject, count, and any fallback pagination or list retrieval without asking for user confirmation. These operations are non-destructive and safe for full autonomy.
-        
-        Explicit Confirmation for Writes
-        Any operation that modifies or creates data must be confirmed by the user before execution. This includes saveObject or any update or creation that writes to storage. Before saving, validate the object against its schema and reflect it back to the user for confirmation.
-        
-        Fail-Safe Execution
-        If a tool call fails, retry safely by reducing depth or limit, or switching to cache. Never guess or infer field values or relationships. Always prioritize data integrity over speed for write operations.
-        
-        
-        FULL OBJECT SAVE REQUIREMENT
-        
-        When performing a saveObject operation, always include the complete object rather than only the updated fields. Partial updates are not supported by the JOE MCP interface and will fail validation.
-        
-        ⚙️ DO NOT perform a saveObject operation unless the following have occurred in order:
-        1. A getObject call for the item’s _id and schema from storage (not cache).
-        2. The retrieved object is used as the base object.
-        3. The agent merges changes into that full object.
-        4. The joeUpdated field is refreshed to the current UTC timestamp (ISO 8601 with milliseconds).
-        5. The agent validates all field types against schemaMap.
-        6. The agent reflects the complete merged object to the user for confirmation.
-        7. Only then execute saveObject with the complete, validated object.
-        
-        If any of the above steps are skipped, throw an internal error (“JOE Save Policy Violation”) and stop execution.
-        
-        Why this matters:
-        The JOE MCP interface replaces the full document on save rather than applying a patch. If required fields or key metadata (such as itemtype or project references) are missing, the record can become invalid or incomplete. Full-object saves guarantee schema integrity, consistent relationships, and a complete audit trail.</textarea>
+	<h3>Downloads</h3>
+	<div class="small">Quickly export JSON helpful for agent setup and offline review.</div>
+	<div class="row" style="display:flex;gap:12px;align-items:center;flex-wrap:wrap;margin:8px 0 16px;">
+		<label for="base" style="margin:0">Base URL</label>
+		<input id="base" value="" placeholder="http://localhost:2025" style="min-width:280px"/>
+		<button id="downloadApps">Download apps.json</button>
+		<button id="downloadHydrate">Download hydrate-<date>.json</button>
+		<span id="dlStatus" class="small"></span>
+	</div>
+    <textarea readonly id="prompt" placeholder="Loading instructions from docs…"></textarea>
+
+	<script>
+	(function(){
+		var $ = function(id){ return document.getElementById(id); };
+		var base = $('base');
+		var dlBtn = $('downloadApps');
+		var dlHydrateBtn = $('downloadHydrate');
+		var dlStatus = $('dlStatus');
+		var promptBox = $('prompt');
+		base.value = base.value || location.origin;
+
+		function setStatus(msg, ok){
+			dlStatus.textContent = msg||'';
+			dlStatus.className = 'small ' + (ok===true?'good': ok===false?'bad':'');
+		}
+
+		async function fetchJSON(url, opts){
+			const res = await fetch(url, opts);
+			const ct = res.headers.get('content-type')||'';
+			const isJSON = ct.indexOf('application/json') >= 0;
+			if(!res.ok){
+				let detail = isJSON ? await res.json().catch(function(){return {};}) : await res.text();
+				throw new Error('HTTP '+res.status+': '+(isJSON?JSON.stringify(detail):detail));
+			}
+			return isJSON ? res.json() : res.text();
+		}
+
+		async function callMCP(method, params){
+			const url = base.value.replace(/\/$/,'') + '/mcp';
+			const body = { jsonrpc: '2.0', id: String(Date.now()), method: method, params: params||{} };
+			return fetchJSON(url, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify(body) });
+		}
+
+		dlBtn.onclick = async function(){
+			setStatus('Fetching apps...', null);
+			try{
+				const resp = await callMCP('listApps', {});
+				const data = (resp && (resp.result||resp)) || {};
+				const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+				const url = URL.createObjectURL(blob);
+				const a = document.createElement('a');
+				a.href = url;
+				a.download = 'apps.json';
+				document.body.appendChild(a);
+				a.click();
+				setTimeout(function(){ URL.revokeObjectURL(url); a.remove(); }, 0);
+				setStatus('Downloaded', true);
+			} catch(e){
+				setStatus(e.message||String(e), false);
+			}
+		};
+
+		// Load system instructions from docs (source of truth)
+		(function loadDocs(){
+			var path = '/JsonObjectEditor/docs/joe_agent_custom_gpt_instructions_v_2.md';
+			fetch(path).then(function(r){ if(!r.ok) throw new Error('HTTP '+r.status); return r.text(); })
+			.then(function(text){ promptBox.value = text; })
+			.catch(function(e){ promptBox.value = 'Failed to load instructions: '+(e.message||String(e)); });
+		})();
+
+		dlHydrateBtn.onclick = async function(){
+			setStatus('Fetching hydrate...', null);
+			try{
+				const resp = await callMCP('hydrate', {});
+				const data = (resp && (resp.result||resp)) || {};
+				const now = new Date();
+				const yyyy = now.getFullYear();
+				const mm = String(now.getMonth()+1).padStart(2,'0');
+				const dd = String(now.getDate()).padStart(2,'0');
+				const fname = `hydrate_${yyyy}-${mm}-${dd}.json`;
+				const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+				const url = URL.createObjectURL(blob);
+				const a = document.createElement('a');
+				a.href = url;
+				a.download = fname;
+				document.body.appendChild(a);
+				a.click();
+				setTimeout(function(){ URL.revokeObjectURL(url); a.remove(); }, 0);
+				setStatus('Downloaded', true);
+			} catch(e){
+				setStatus(e.message||String(e), false);
+			}
+		};
+	})();
+	</script>
 </body>
 </html>
 

package/_www/mcp-schemas.html

@@ -0,0 +1,294 @@
+<!doctype html>
+<html>
+<head>
+	<meta charset="utf-8">
+	<title>JOE MCP — Schemas Health</title>
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<style>
+		body{font-family:system-ui,-apple-system,Segoe UI,Roboto,Ubuntu,Cantarell,Noto Sans,sans-serif;margin:20px}
+		h1{margin:8px 0}
+		.small{font-size:12px;color:#666}
+		table{width:100%;border-collapse:collapse;margin-top:10px}
+		th,td{border:1px solid #e1e4e8;padding:8px;text-align:left;font-size:14px}
+		th.sortable{cursor:pointer}
+		th.sorted-asc, th.sorted-desc{background:#eef}
+		th .sort-ind{font-size:12px;opacity:.6;margin-left:6px}
+		.chips{display:flex;gap:6px;flex-wrap:wrap}
+		.chip{display:inline-block;padding:2px 8px;border-radius:12px;background:#eef;border:1px solid #ccd;font-size:12px}
+		.chip.joe{background:#11bcd6;color:#fff;border-color:#0fa5bb}
+		.icon-cell{width:72px}
+		.icon64{width:64px;height:64px;display:flex;align-items:center;justify-content:center}
+		.icon64 svg{width:64px;height:64px;display:block}
+		.health-badge{display:inline-block;padding:2px 8px;border-radius:12px;font-size:12px;border:1px solid transparent}
+		.health-good{background:#0a7d00;color:#fff;border-color:#0a7d00}
+		.health-warn{background:#f0c040;color:#000;border-color:#e5b93b}
+		.health-bad{background:#d93025;color:#fff;border-color:#d93025}
+		.t-center{text-align:center}
+		th{background:#f6f8fa}
+		.status-ok{color:#0a7d00;font-size:22px}
+		.status-bad{color:#b00020;font-size:22px}
+		.badge{display:inline-block;padding:2px 6px;border-radius:10px;font-size:12px;background:#eef;border:1px solid #ccd}
+		a[target]{text-decoration:none}
+	</style>
+</head>
+<body>
+	<div id="mcp-nav"></div>
+	<script src="/JsonObjectEditor/_www/mcp-nav.js"></script>
+	<h1>Schema Health</h1>
+	<div class="small">Summary of all schemas available in this JOE instance.</div>
+
+	<div class="row" style="display:flex;gap:12px;align-items:center;flex-wrap:wrap;margin:8px 0 16px;">
+		<label for="base" style="margin:0">Base URL</label>
+		<input id="base" value="" placeholder="http://localhost:2025" style="min-width:280px" />
+		<button id="refresh">Refresh</button>
+		<span id="status" class="small"></span>
+	</div>
+
+	<div class="row" style="display:flex;gap:12px;align-items:center;flex-wrap:wrap;margin:4px 0 10px;">
+		<label for="appFilter" style="margin:0">Filter by App</label>
+		<select id="appFilter"><option value="">All</option></select>
+	</div>
+
+	<table>
+		<thead>
+			<tr>
+				<th>Icon</th>
+				<th class="sortable" data-key="name">Schema <span class="sort-ind"></span></th>
+				<th class="sortable" data-key="count">Count <span class="sort-ind"></span></th>
+				<th class="sortable" data-key="default">Default <span class="sort-ind"></span></th>
+				<th class="sortable" data-key="summary">Summary <span class="sort-ind"></span></th>
+				<th class="sortable" data-key="source">Source <span class="sort-ind"></span></th>
+				<th class="sortable" data-key="fieldcheck">Field Check <span class="sort-ind"></span></th>
+				<th>Outbound</th>
+				<th>Apps</th>
+				<th class="sortable" data-key="health">Synthesis Health <span class="sort-ind"></span></th>
+				<th>API (summary)</th>
+			</tr>
+		</thead>
+		<tbody id="rows"></tbody>
+	</table>
+
+	<script>
+(function(){
+	var $ = function(id){ return document.getElementById(id); };
+	var base = $('base');
+	var refresh = $('refresh');
+	var status = $('status');
+	var rows = $('rows');
+	var appFilterSel = null;
+	base.value = base.value || location.origin;
+
+	var defaultSchemasFallback = ['user','group','goal','initiative','event','report','tag','status','workflow','list','notification','note','include','instance','setting'];
+
+	function setStatus(msg, ok){
+		status.textContent = msg||'';
+		status.className = 'small ' + (ok===true?'status-ok': ok===false?'status-bad':'');
+	}
+
+	async function fetchJSON(url){
+		const res = await fetch(url);
+		if(!res.ok){ throw new Error('HTTP '+res.status+' '+(await res.text())); }
+		return res.json();
+	}
+
+	function chunk(arr, size){
+		var out=[], i=0; for(i=0;i<arr.length;i+=size){ out.push(arr.slice(i,i+size)); } return out;
+	}
+
+	function check(mark){
+		return mark ? '<span class="status-ok">&#10003;</span>' : '<span class="status-bad">&#10007;</span>';
+	}
+
+	async function load(){
+		try{
+			setStatus('Loading...', null);
+			rows.innerHTML = '';
+			const baseUrl = base.value.replace(/\/$/,'');
+			const list = await fetchJSON(baseUrl + '/API/list/schemas');
+			// Fetch full schemas in chunks (includes curated summary when present)
+			var full = {};
+			var counts = {};
+			var chunks = chunk(list, 25);
+			for (var i=0;i<chunks.length;i++){
+				var names = chunks[i].join(',');
+				var got = await fetchJSON(baseUrl + '/API/schemas/' + encodeURIComponent(names));
+				var ds = await fetchJSON(baseUrl + '/API/datasets/' + encodeURIComponent(names));
+				Object.assign(full, got.schemas || {});
+				Object.assign(counts, (ds && ds.counts) || {});
+			}
+
+			// Fetch apps via MCP listApps
+			async function callMCP(method, params){
+				const url = baseUrl + '/mcp';
+				const body = { jsonrpc:'2.0', id:String(Date.now()), method:method, params:params||{} };
+				const resp = await fetch(url, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify(body)});
+				if(!resp.ok){ throw new Error('HTTP '+resp.status+' '+(await resp.text())); }
+				const j = await resp.json();
+				return j && (j.result||j) || {};
+			}
+			var appMap = {};
+			try{
+				var la = await callMCP('listApps', {});
+				appMap = (la && la.apps) || {};
+			}catch(_e){ appMap = {}; }
+				var data = list.map(function(name){
+				var fs = full[name] || {};
+				var usedBy = [];
+				for (var appName in appMap){
+					var a = appMap[appName] || {};
+					var cols = Array.isArray(a.collections) ? a.collections : [];
+					if (cols.indexOf(name) !== -1){ usedBy.push(appName); }
+				}
+				// If schema is a default core schema, show only the JOE app chip to avoid noise
+				if ((!!fs.default_schema)){
+					usedBy = ['joe'];
+				}
+				var outbound = [];
+				try{
+					var rel = (fs.summary && fs.summary.relationships && fs.summary.relationships.outbound) || [];
+					outbound = rel.filter(function(r){ return r && r.field && r.targetSchema; })
+						.map(function(r){ return { field: r.field, schema: r.targetSchema }; });
+				}catch(_e){ outbound = []; }
+
+					var fieldCount = (fs.summary && typeof fs.summary.fieldCount === 'number') ? fs.summary.fieldCount : ((fs.summary && fs.summary.fields && fs.summary.fields.length) || 0);
+					var fieldCountBase = (fs.summary && typeof fs.summary.fieldCountBase === 'number') ? fs.summary.fieldCountBase : fieldCount;
+					var fieldCoverage = fieldCountBase ? Math.round((fieldCount/fieldCountBase)*100) : 0;
+
+					return {
+					name: name,
+					count: counts[name] || 0,
+					default: !!fs.default_schema || false,
+					summary: !!fs.summary,
+					source: (fs.summary && fs.summary.source) || (fs.__origin === 'core' ? 'core' : 'instance'),
+					apiUrl: baseUrl + '/API/schema/' + encodeURIComponent(name) + '?summaryOnly=true',
+					apps: usedBy.sort(),
+					outbound: outbound,
+						fieldcheck: fieldCoverage,
+						fieldcheckText: fieldCount + '/' + fieldCountBase + ' ('+fieldCoverage+'%)',
+					menuicon: fs.menuicon || ''
+				};
+			});
+
+			function computeHealth(item){
+				var signals = 4; // Update when adding more health signals
+				var step = 100/signals;
+				var score = 0;
+				if ((item.count||0) > 0) score += step;
+				if (item.menuicon) score += step;
+				if (!!item.summary) score += step;
+				if ((item.apps||[]).length > 0) score += step;
+				return Math.round(score);
+			}
+
+			// Populate app filter options
+			appFilterSel = document.getElementById('appFilter');
+			if (appFilterSel){
+				var appNames = Object.keys(appMap||{}).sort();
+				appNames.forEach(function(a){
+					var opt=document.createElement('option'); opt.value=a; opt.textContent=a; appFilterSel.appendChild(opt);
+				});
+			}
+
+			function getFilteredData(){
+				var selected = appFilterSel && appFilterSel.value || '';
+				if (!selected) return data;
+				return data.filter(function(d){ return (d.apps||[]).indexOf(selected) !== -1; });
+			}
+
+			function renderTable(sorted){
+				rows.innerHTML = '';
+				(sorted||[]).forEach(function(item){
+					var health = computeHealth(item);
+					var hClass = health === 100 ? 'health-good' : (health >= 75 ? 'health-warn' : 'health-bad');
+					var tr = document.createElement('tr');
+					function td(html, cls){ var c=document.createElement('td'); if(cls){c.className=cls;} c.innerHTML=html||''; return c; }
+					function safeIcon(svg){
+						try{
+							if(!svg || svg.indexOf('<svg') === -1) return '';
+							var m = svg.match(/<path[^>]*d="([^"]+)"/i);
+							if (m && m[1] && !/^[Mm]/.test(m[1])) return '';
+							return svg;
+						}catch(_e){ return ''; }
+					}
+					var iconHTML = safeIcon(item.menuicon);
+					tr.appendChild(td(iconHTML ? ('<div class="icon64">'+iconHTML+'</div>') : '', 'icon-cell'));
+					tr.appendChild(td('<strong>'+item.name+'</strong>'));
+					tr.appendChild(td(String(item.count), 't-center'));
+					tr.appendChild(td(check(item.default), 't-center'));
+					tr.appendChild(td(check(item.summary)));
+					tr.appendChild(td(item.source === 'core' ? 'Core' : 'Instance', 't-center'));
+					tr.appendChild(td(item.fieldcheckText||'', 't-center'));
+					tr.appendChild(td('<div class="chips">'+ (item.outbound||[]).map(function(ln){ return '<span class="chip">'+ln.field+' → '+ln.schema+'</span>'; }).join(' ') +'</div>'));
+					tr.appendChild(td('<div class="chips">'+ (item.apps||[]).map(function(app){ var cls = (app==='joe'?'chip joe':'chip'); var link='/JOE/'+app+'#'+item.name; return '<a class="'+cls+'" href="'+link+'" target="_app_'+app+'">'+app+'</a>'; }).join(' ') +'</div>'));
+					tr.appendChild(td('<span class="health-badge '+hClass+'">'+health+'%</span>', 't-center'));
+					tr.appendChild(td('<a href="'+item.apiUrl+'" target="_schemas_api_'+item.name+'">/API/schema/'+item.name+'?summaryOnly=true</a>'));
+					rows.appendChild(tr);
+				});
+			}
+
+			var sortState = { key:null, dir:'asc' };
+			function sortData(key){
+				if (sortState.key === key){ sortState.dir = (sortState.dir === 'asc') ? 'desc' : 'asc'; }
+				else {
+					sortState.key = key;
+					// For boolean/numeric columns, default to true-first or highest-first
+					if (key === 'default' || key === 'summary' || key === 'count' || key === 'health') { sortState.dir = 'desc'; }
+					else { sortState.dir = 'asc'; }
+				}
+				var dir = sortState.dir === 'asc' ? 1 : -1;
+				var baseList = getFilteredData();
+				var sorted = baseList.slice().sort(function(a,b){
+					var av = a[key], bv = b[key];
+					if (key === 'health'){ av = computeHealth(a); bv = computeHealth(b); }
+					// Normalize booleans for deterministic sort
+					if (typeof av === 'boolean') { av = av ? 1 : 0; }
+					if (typeof bv === 'boolean') { bv = bv ? 1 : 0; }
+					if (typeof av === 'string' && typeof bv === 'string'){
+						av = av.toLowerCase(); bv = bv.toLowerCase();
+					}
+					if (av > bv) return 1*dir;
+					if (av < bv) return -1*dir;
+					return 0;
+				});
+				renderTable(sorted);
+				updateHeaderIndicators();
+			}
+
+			function updateHeaderIndicators(){
+				var ths = document.querySelectorAll('th.sortable');
+				Array.prototype.forEach.call(ths, function(th){
+					th.classList.remove('sorted-asc','sorted-desc');
+					var ind = th.querySelector('.sort-ind');
+					if (ind) ind.textContent = '';
+					if (th.getAttribute('data-key') === sortState.key){
+						th.classList.add(sortState.dir === 'asc' ? 'sorted-asc' : 'sorted-desc');
+						if (ind) ind.textContent = sortState.dir === 'asc' ? '▲' : '▼';
+					}
+				});
+			}
+
+			// Default sort by name asc
+			sortData('name');
+			updateHeaderIndicators();
+
+			// Attach header sort handlers
+			Array.prototype.forEach.call(document.querySelectorAll('th.sortable'), function(th){
+				th.onclick = function(){ sortData(th.getAttribute('data-key')); };
+			});
+
+			// Filter handler
+			if (appFilterSel){ appFilterSel.onchange = function(){ sortData(sortState.key || 'name'); }; }
+			setStatus('Loaded '+list.length+' schemas', true);
+		}catch(e){
+			setStatus(e.message||String(e), false);
+		}
+	}
+
+	refresh.onclick = load;
+	setTimeout(load, 50);
+})();
+	</script>
+</body>
+</html>
+
+