json-object-editor 0.10.508 → 0.10.520

package/_www/mcp-test.html

@@ -38,6 +38,12 @@
 	<div class="preset">
 		<button id="presetFuzzyUser">fuzzySearch users: q="corey hadden"</button>
 		<button id="presetFuzzyHouse">fuzzySearch houses: q="backyard"</button>
+		<button id="presetListApps">listApps: all app definitions</button>
+		<button id="presetGetSchemas">getSchemas: ["client","user"]</button>
+		<button id="presetGetSchemasSummary">getSchemas (summaryOnly): ["task","project"]</button>
+		<button id="presetSearchSlimRecent">search clients (slim, recent)</button>
+		<button id="presetSearchWithCount">search clients (withCount)</button>
+		<button id="presetSearchCountOnly">search clients (countOnly)</button>
 	</div>
 	
 	<h3>Call JSON-RPC</h3>
@@ -63,12 +69,29 @@
 		const result = $('result');
 		const presetFuzzyUser = $('presetFuzzyUser');
 		const presetFuzzyHouse = $('presetFuzzyHouse');
+		const presetListApps = $('presetListApps');
+		const presetGetSchemas = $('presetGetSchemas');
+		const presetGetSchemasSummary = $('presetGetSchemasSummary');
+		const presetSearchSlimRecent = $('presetSearchSlimRecent');
+		const presetSearchWithCount = $('presetSearchWithCount');
+		const presetSearchCountOnly = $('presetSearchCountOnly');
 		
 		// Try to infer base from window location
 		base.value = base.value || (location.origin);
 		
 		let manifest = null;
 		let idCounter = 1;
+
+		function ensureTool(name, meta){
+			if (!manifest) { manifest = { tools: [] }; }
+			manifest.tools = manifest.tools || [];
+			var existing = (manifest.tools||[]).find(function(t){ return t && t.name === name; });
+			if (!existing && meta) { manifest.tools.push(meta); }
+			// ensure option exists in select
+			var hasOpt = false;
+			for (var i=0;i<toolSel.options.length;i++){ if (toolSel.options[i].value === name) { hasOpt = true; break; } }
+			if (!hasOpt){ var opt=document.createElement('option'); opt.value=name; opt.textContent=name; toolSel.appendChild(opt); }
+		}
 		
 		function setStatus(el, msg, ok){
 			el.textContent = msg || '';
@@ -133,6 +156,53 @@
 			renderToolInfo();
 			params.value = JSON.stringify({ q: 'backyard', filters: { itemtype: 'house' }, threshold: 0.5 }, null, 2);
 		};
+		presetListApps.onclick = function(){
+			toolSel.value = 'listApps';
+			renderToolInfo();
+			params.value = JSON.stringify({}, null, 2);
+		};
+
+		presetGetSchemas.onclick = function(){
+			ensureTool('getSchemas', {
+				name: 'getSchemas',
+				description: 'Retrieve multiple schema definitions. If omitted, returns all.',
+				params: { type: 'object', properties: { names: { type: 'array', items: { type: 'string' } } } },
+				returns: { type: 'object' }
+			});
+			toolSel.value = 'getSchemas';
+			renderToolInfo();
+			params.value = JSON.stringify({ names: ["client", "user"] }, null, 2);
+		};
+
+		presetGetSchemasSummary.onclick = function(){
+			ensureTool('getSchemas', {
+				name: 'getSchemas',
+				description: 'Retrieve multiple schemas. With summaryOnly=true, returns summaries; if names omitted, returns all.',
+				params: { type: 'object', properties: { names: { type: 'array', items: { type: 'string' } }, summaryOnly: { type: 'boolean' } } },
+				returns: { type: 'object' }
+			});
+			toolSel.value = 'getSchemas';
+			renderToolInfo();
+			params.value = JSON.stringify({ names: ["task", "project"], summaryOnly: true }, null, 2);
+		};
+
+		presetSearchSlimRecent.onclick = function(){
+			toolSel.value = 'search';
+			renderToolInfo();
+			params.value = JSON.stringify({ schema: 'client', source: 'cache', query: { itemtype: 'client' }, limit: 25, sortBy: 'joeUpdated', sortDir: 'desc', slim: true }, null, 2);
+		};
+
+		presetSearchWithCount.onclick = function(){
+			toolSel.value = 'search';
+			renderToolInfo();
+			params.value = JSON.stringify({ schema: 'client', source: 'cache', query: { itemtype: 'client' }, limit: 25, withCount: true, sortBy: 'joeUpdated', sortDir: 'desc' }, null, 2);
+		};
+
+		presetSearchCountOnly.onclick = function(){
+			toolSel.value = 'search';
+			renderToolInfo();
+			params.value = JSON.stringify({ schema: 'client', source: 'cache', query: { itemtype: 'client' }, countOnly: true }, null, 2);
+		};
 		
 		callBtn.onclick = async function(){
 			setStatus(callStatus, 'Calling...', null);

package/docs/JOE_Master_Knowledge_Export.md

@@ -0,0 +1,135 @@
+# JOE (Json Object Editor) — Master Knowledge
+Last updated: Oct 2025
+
+## What is JOE?
+JOE is a schema‑first, lightweight, extensible admin platform and data workbench. It manages structured objects via dynamic, schema‑driven forms and list views.
+
+- Server/Platform mode: Node.js app with storage backends, cache, plugins, apps, web UI, and MCP tools for agents.
+- Client‑only mode: Embed `JsonObjectEditor` to render/edit objects in‑page using schemas.
+
+## Purpose and who it's for
+- JOE turns whatever your organization does into living JSON objects with relationships and history. If it can be described, it can be represented and managed in JOE.
+- For any org size or type: businesses, non‑profits, churches, families, clubs, and projects.
+- Use JOE to:
+  - Model your domain (schemas) and manage data with zero/low code
+  - Operate with lists, dashboards, statuses, tags, and reports
+  - Coordinate across teams via curated apps per use‑case
+  - Empower agents (via MCP) to search, reconcile, and update data safely
+- Benefits: rapid time‑to‑value, consistent UI/flows, single source of truth, clean audit history, and agent‑friendly APIs.
+
+## Where JOE fits (when to use vs not)
+- Use JOE when you need:
+  - Schema‑first CRUD/admin surfaces with evolving data models
+  - Unified views over multiple datasets with fast cache reads
+  - Lightweight workflows (statuses/tags), reports, and agent tooling
+- Not a great fit when you need:
+  - Heavy bespoke transactional systems requiring complex ACID workflows
+  - Offline‑first mobile or hard real‑time (sub‑ms) constraints
+  - Highly specialized UIs better served by purpose‑built apps (you can still use JOE as the data/admin layer)
+
+## Core principles
+- Schema‑first: behavior and UI flow derive from schemas.
+- Separation of concerns: schemas define data and rules; UI renders dynamically.
+- Minimal overhead: lean client rendering, unified server APIs, cache‑first reads.
+- Extensibility: apps, plugins, and instance schemas compose capabilities.
+- Single‑object overlay: focused edit/view with list/detail navigation.
+
+## Mental model
+- Objects conform to schemas; schemas define fields, validation, menus, filters, events.
+- Reads prefer cache for speed; writes go through storage for durability.
+- `saveObject` emits events (create/save/status/delete), writes history, and broadcasts via sockets.
+- Universal shorthand `$J` exists on server and client for quick access.
+
+## System overview
+- Global `JOE` (from `server/init.js`) exposes:
+  - `JOE.Utils`, `JOE.Schemas`, `JOE.Storage`, `JOE.Cache`, `JOE.Apps`, `JOE.Server` (Express), `JOE.Sites`, `JOE.io` (Socket), `JOE.Mongo`/`JOE.MySQL`, `JOE.auth`.
+  - Hot‑reload module pattern: modules may export `init()` and are watched/reloaded.
+- Instance directories:
+  - `_schemas`: schema definitions loaded by `JOE.Schemas`
+  - `_apps`: app definitions (collections, dashboards, UX)
+  - `_plugins`: backend features (auth, forms, reports, calendar, etc.)
+  - `_templates`: templates/layouts; `_datasets`: seed/aux data; `_files`: uploads; `_www`: static (includes MCP pages)
+- Shorthand `$J`: `$J.get(_id[, schema])`, `$J.search(query)`, `$J.schema(name)`.
+
+## Apps (the use‑case layer)
+Apps are the layer between core JOE and an instance’s additional schemas. They curate the right data surfaces and UI for a use case by:
+
+- Selecting relevant collections (schemas) for the app’s domain
+- Defining dashboards, cards, reports, and default filters/subsets
+- Wiring applicable plugins and lightweight workflows
+
+Think of apps as scoped workspaces: they present a coherent subset of “everything JOE can do” plus instance‑specific schemas and UI that match the task at hand. Agents can use apps conceptually to understand a domain’s surface area without needing every schema in the instance.
+
+## Schemas and fields (high‑level)
+- Schema keys: `title`, `fields` (visible), `_listID`, `_listTitle`, menus, filters, events, optional `tableView`.
+- Field properties: `label`, `type`, `value/default`, `hidden`, `locked`, `condition`, `width`, `tooltip`, `comment`, plus type‑specific props.
+- Common field types: `text`, `number`, `int`, `select`, `boolean`, `date`, `geo`, `image`, `objectlist`, `objectReference`, `content`, `rendering`, `code`, `button`.
+- Page helpers: `section_start/_label/_end`, `sidebar_start/_label/_end`.
+- Events: schema‑level on `create`, `save`, `status`, `delete`.
+- Statuses/tags: first‑class objects used across workflows and labeling.
+
+## Server APIs and MCP (model context)
+
+### REST highlights
+- Exact search via `/API/search` (default). Fuzzy mode available with `mode=fuzzy` and params: `q`, `fields`, `threshold`, `limit`, `offset`, `highlight`. Default weighted fields: name (0.6), info (0.3), description (0.1).
+
+### MCP bridge (for agents)
+- Manifest: `GET /.well-known/mcp/manifest.json` (public)
+- JSON‑RPC: `POST /mcp` (auth‑protected when users exist)
+- Core tools (master doc surface):
+  - `listSchemas` — names of available schemas
+  - `getSchema` — schema definition by name
+  - `search` — exact search (defaults to cache; set `source:"storage"` for DB)
+  - `fuzzySearch` — typo‑tolerant search with optional weighted fields
+  - `getObject` — fetch single object by `_id` (optional `schema`, `flatten`, `depth`)
+  - `saveObject` — create/update an object (fires events/history)
+  - `hydrate` — returns core fields, schema names, statuses, tags for context boot
+
+Note: Additional MCP tools exist; see deeper‑dive docs for the complete surface.
+
+## Agent integration and save policy
+- Start of session: call `hydrate {}` to prime context, then `listSchemas`/`getSchema` as needed.
+- Query strategy: prefer cache for speed; use storage for authoritative reads or post‑save validation; for large result sets, `search { countOnly: true }` first.
+- Save policy (canonical): always save the full validated object (not a partial diff). Recommended flow: get from storage → merge changes → set `joeUpdated` → validate against schema → reflect final object to user → `saveObject`.
+- Rationale: clean, consistent history and versioning; predictable integrity on write.
+
+## Instance setup (concise)
+- Config: see `server/webconfig.js` for defaults (e.g., `PORT`, `hostname`, `joedb`, `joepath` `/JsonObjectEditor/`).
+- Structure: keep instance‑specific `_schemas`, `_apps`, `_plugins`, `_templates`, `_datasets`, `_files` at the project root alongside JOE; JOE auto‑watches and loads these.
+- Static & tools: JOE serves `_www` both under `joepath` and as a root fallback, exposing MCP pages: `/mcp-test.html`, `/mcp-export.html`, `/mcp-prompt.html`.
+- Identity for agents: the MCP manifest surfaces instance info (`name`, `version`, `hostname`). Agents should always hydrate and then treat apps as domain‑specific lenses over the instance’s schemas and data.
+
+## Operations and behavior
+- Storage backends per schema: `mongo`, `mysql`, `file`, `api` (fallbacks included). Missing IDs are assigned on save (prefers `cuid()`, fallback to GUID).
+- Cache: `JOE.Cache.update` builds `JOE.Data` (by collection), a flattened list, and a `lookup` for fast ID resolution; `$J.search()` hits cache by default.
+- History/events/sockets: saves create `_history` records, fire schema events, and emit `item_updated` to clients.
+- Auth: Basic Auth recommended currently; OAuth2 plugin exists but is being hardened.
+- Security: MCP tools sanitize sensitive fields; `/privacy` and `/terms` are public and use `Setting: PRIVACY_CONTACT` for contact email.
+
+## Best practices
+- Keep business rules and relationships in schemas; use dynamic `propAsFuncOrValue` where supported.
+- Use delegated actions for interactive UI (e.g., `joe-button` with `action="..."`).
+- Prefer cache for reads; use storage for accuracy‑critical operations.
+- After updates, refresh overlays (`_joe.show()`), or fetch fresh via `_joe.Object.getFromServer(id, { goto: true })` when needed.
+- Never suppress errors; surface and handle validation explicitly.
+- Agents: hydrate first, scope results (limit 10–25), and always confirm before `saveObject`.
+
+## Known limitations and roadmap
+- OAuth2/SSO via plugin (currently buggy; Basic Auth recommended short‑term)
+- Pagination and streaming for extremely large datasets
+- Not offline‑first
+- Optional audit trail is basic (history collection)
+- Packaging: future Docker bundles for admin + server
+
+## Quick references
+- MCP manifest: `GET /.well-known/mcp/manifest.json`
+- MCP call template (JSON‑RPC):
+```json
+{ "jsonrpc": "2.0", "id": "1", "method": "<tool>", "params": { } }
+```
+- Fuzzy search (JSON‑RPC example):
+```json
+{ "jsonrpc":"2.0", "id":"6", "method":"fuzzySearch", "params": { "schema":"<schema>", "q":"term", "threshold":0.5, "limit":25 } }
+```
+
+

package/docs/joe_agent_custom_gpt_instructions_v_2.md

@@ -0,0 +1,54 @@
+# JOE Agent — CustomGPT System Instructions (v2.2)
+
+You are the JOE Agent, a schema‑aware data assistant for the JOE platform. You manage data objects according to JOE’s schema definitions and operational policies.
+
+Note: You have access to schema definitions and relationships via hydrate (schemaSummary). Use them to reason about data, generate queries, and interpret object references accurately.
+
+## Start‑up sequence
+- Call `hydrate {}` to preload:
+  - `schemaSummary` with normalized per‑schema metadata (labelField, defaultSort, searchableFields, allowedSorts, relationships.outbound, joeManagedFields, fields)
+  - global datasets like `status`, `tag`
+- Cache the `schemaSummary` map and prefer it over parsing full schemas.
+
+## Core behavior
+- Use `schemaSummary[*]`:
+  - For field shapes (type, isArray, isReference, targetSchema, enumValues)
+  - For search targeting (searchableFields) and safe sorting (allowedSorts, defaultSort)
+  - For link resolution (relationships.outbound) and display names (labelField)
+- Do not assume inbound relationships; rely on outbound + lookups.
+- Reads are autonomous; writes require explicit confirmation.
+
+## Tool usage
+- listSchemas {} → names
+- getSchemas { names?, summaryOnly: true } → summaries (prefer for planning)
+- getSchema { name, summaryOnly: true } → summary for one schema
+- search { schema?, query?, ids?, source?, limit?, offset?, sortBy?, sortDir?, slim?, withCount?, countOnly? }
+  - Default: cache; use `source: "storage"` for authoritative reads
+  - Use `withCount` or `countOnly` before fetching large pages; paginate
+  - Use `sortBy` from `allowedSorts`; fall back to `defaultSort`
+- getObject { _id, schema?, flatten?, depth? }
+- saveObject { object }
+
+## Safe update flow
+1) getSchema { name, summaryOnly: true } or use hydrate.schemaSummary
+2) Read object from storage
+3) Merge user changes; update `joeUpdated` to current UTC
+4) Validate fields/types using summary
+5) Reflect final object and confirm
+6) saveObject { object }
+
+## Query guidance
+- Use `searchableFields` to build text queries and `allowedSorts` for ordering
+- Use `relationships.outbound` to fetch or verify references (e.g., status, project, tags)
+- Prefer `slim: true` for browsing; get details with `getObject`
+
+## Output style
+- Be succinct; show IDs and key fields; propose next actions
+- For long results: summarize and offer to refine or paginate
+
+## Examples
+- “List schemas” → listSchemas {}
+- “What fields does ‘task’ have?” → getSchema { "name": "task", "summaryOnly": true }
+- “Find 25 recent tasks” → search { "schema": "task", "limit": 25, "sortBy": "joeUpdated", "sortDir": "desc", "slim": true, "withCount": true }
+- “Show task 123” → getObject { "_id": "123", "schema": "task" }
+- “Update task 123 name” → saveObject { "object": { "_id": "123", "itemtype": "task", "name": "New Name" } }

package/docs/joe_agent_spec_v_2.2.md

@@ -0,0 +1,64 @@
+---
+version: 2.2
+author: JOE Team
+effective_date: 2025-10-29
+type: Agent Specification
+summary: Update emphasizes hydrate + schemaSummary for planning, querying, and validation.
+---
+
+# JOE Agent — Layered Instruction Framework (v2.2)
+
+Access model: You have access to schema definitions and relationships via hydrate (schemaSummary). Use them to reason about data, generate queries, and interpret object references accurately.
+
+## Layer 1: Core Rules
+- Hydration First — call `hydrate {}` and cache `schemaSummary`
+- Reference Resolution — use outbound links from summaries; resolve IDs via `getObject` when needed
+- Schema Validation — use summary fields (type, enumValues, isArray, isReference, targetSchema)
+- Full‑Object Saves — read from storage, merge, confirm, save
+- Human Confirmation — any write must be confirmed
+
+## Layer 2: Smart Autonomy
+- Cache‑First Reads — default `source: "cache"`; use `storage` for post‑save validation
+- Efficient Querying — prefer `withCount` or `countOnly`, then paginate (25–50)
+- Sorting — use `allowedSorts`; default to schema’s `defaultSort`
+- Discovery — prefer `getSchemas { summaryOnly: true }` over full schemas
+- Slim Browsing — use `slim: true` to reduce payload; fetch details on demand
+
+## Layer 3: Interaction
+- Be concise; show key fields, IDs; offer next steps
+- Explain errors plainly; propose fixes (e.g., choose a valid enum value)
+
+## Layer 4: Developer Transparency
+- Narrate tool calls when `devMode=true`
+- Show `{ _id, name, itemtype, joeUpdated }` summaries for long lists
+
+## Layer 5: System Policies
+- Never expose secrets or tokens
+- Use `joeManagedFields` to avoid overwriting server‑managed values
+- Treat inbound relationships as derived; do not assume without evidence
+
+## Hydration Utilization
+- schemaSummary[*].labelField — prefer for display names
+- schemaSummary[*].searchableFields — build queries
+- schemaSummary[*].allowedSorts / defaultSort — safe sorting
+- schemaSummary[*].relationships.outbound — resolve references (status, project, tags, etc.)
+- schemaSummary[*].fields — types, enumValues, arrays, reference targets
+- schemaSummaryGeneratedAt — refresh caches when this changes
+
+## Tooling
+- listSchemas / getSchemas (summaryOnly)
+- search (limit, offset, sortBy, sortDir, slim, withCount, countOnly)
+- getObject / saveObject
+
+## Save Policy
+1. getSchema(summaryOnly) or hydrate summary
+2. Read from storage
+3. Merge; update joeUpdated (UTC)
+4. Validate against summary fields
+5. Confirm with user
+6. saveObject
+
+## Large Data Strategy
+- Probe with `countOnly` then paginate
+- Use `slim` and fetch details by ID
+- Return download links for extreme outputs; avoid dumping massive JSON inline

package/docs/schema_summary_guidelines.md

@@ -0,0 +1,128 @@
+# JOE Schema Summary — Rules and Prompts
+
+Purpose: Provide a consistent, agent‑friendly summary for each schema (including instance‑specific ones) so tools and UIs can reason without parsing full runtime schema files.
+
+These summaries are served by MCP hydrate and by GET `/API/schema/:name?summaryOnly=true`.
+
+## What to include in every summary
+
+- description: One‑sentence explanation of what the schema represents
+- purpose: When/why to use it; context among related schemas
+- wip: true if the schema is under active development
+- source: 'core' | 'instance' (filled automatically; you can override)
+- labelField: Primary human label (prefer name → title → label)
+- defaultSort: { field, dir } sensible default (prefer joeUpdated desc; pages often path asc; posts often post_date desc)
+- searchableFields: Array of string field names that are good for text queries
+- allowedSorts: Whitelist of sortable fields agents should use
+- relationships:
+  - outbound: Array of { field, targetSchema, cardinality } where cardinality is 'one' | 'many'
+  - inbound: { graphRef: 'server/relationships.graph.json' } (do not hand‑maintain inbound; it’s computed from the graph later)
+- joeManagedFields: ["created","joeUpdated"] (always include)
+- fields: Array of normalized field descriptors:
+  - Required: name, type
+  - Optional: isArray, isReference, targetSchema, enumValues, display, comment, tooltip, format
+
+Notes
+- display/comment/tooltip are enriched automatically at runtime from the schema’s field definitions; include them in the summary when they clarify usage.
+- For select fields, add enumValues when known (e.g., role, priority, content_type).
+
+## Cardinality guidance
+
+- A single reference (select/goto a single item) → 'one'
+- Arrays, objectList, or multi‑select references → 'many'
+
+## Heuristics (when unsure)
+
+- labelField: name → title → label
+- defaultSort: joeUpdated desc; pages: path asc; posts: post_date desc
+- searchableFields: name, info, description, plus any user‑visible identifiers (code, slug, email)
+- allowedSorts: include dates (joeUpdated, created, due_date), labelField, and common categoricals
+
+## Authoring prompt (for new instance‑specific schemas)
+
+Use this prompt to draft a `summary` block to paste into the schema file.
+
+```
+You are defining a curated summary for a JOE schema named <SCHEMA_NAME>.
+Return strictly a JSON object with these keys:
+{
+  "description": "…",
+  "purpose": "…",
+  "labelField": "…",
+  "defaultSort": { "field": "…", "dir": "asc|desc" },
+  "searchableFields": ["…"],
+  "allowedSorts": ["…"],
+  "relationships": {
+    "outbound": [
+      { "field": "<field>", "targetSchema": "<schema>", "cardinality": "one|many" }
+    ],
+    "inbound": { "graphRef": "server/relationships.graph.json" }
+  },
+  "joeManagedFields": ["created","joeUpdated"],
+  "fields": [
+    {
+      "name": "…",
+      "type": "string|number|boolean|date-time|object|objectList|select|…",
+      "isArray": false,
+      "isReference": false,
+      "targetSchema": null,
+      "enumValues": [ ],
+      "display": "…",
+      "comment": "…",
+      "tooltip": "…",
+      "format": "date|date-time|…"
+    }
+  ]
+}
+Rules:
+- Only include fields that materially help an agent construct/validate objects or reason about references.
+- Prefer concise, high‑signal text for description and purpose.
+- Do NOT populate inbound manually; leave graphRef as is.
+- Include enumValues for selects where known; omit when unknown.
+```
+
+## Example (task)
+
+```
+summary: {
+  description: "Scheduled unit of work tracked for users and projects.",
+  purpose: "Use to plan and execute work; references status, project, members, tags.",
+  labelField: "name",
+  defaultSort: { field: "joeUpdated", dir: "desc" },
+  searchableFields: ["name","info","description","_id"],
+  allowedSorts: ["joeUpdated","created","due_date","priority","name"],
+  relationships: {
+    outbound: [
+      { field: "status", targetSchema: "status", cardinality: "one" },
+      { field: "project", targetSchema: "project", cardinality: "one" },
+      { field: "members", targetSchema: "user", cardinality: "many" },
+      { field: "tags", targetSchema: "tag", cardinality: "many" }
+    ],
+    inbound: { graphRef: "server/relationships.graph.json" }
+  },
+  joeManagedFields: ["created","joeUpdated"],
+  fields: [
+    { name: "_id", type: "string" },
+    { name: "itemtype", type: "string" },
+    { name: "name", type: "string" },
+    { name: "status", type: "string", isReference: true, targetSchema: "status" },
+    { name: "project", type: "string", isReference: true, targetSchema: "project" },
+    { name: "members", type: "string", isArray: true, isReference: true, targetSchema: "user" },
+    { name: "tags", type: "string", isArray: true, isReference: true, targetSchema: "tag" },
+    { name: "priority", type: "number", enumValues: [1,2,3,1000] },
+    { name: "joeUpdated", type: "date-time" },
+    { name: "created", type: "date-time" }
+  ]
+}
+```
+
+## How to validate quickly
+
+- Open: `/API/schema/<name>?summaryOnly=true`
+- Check: description/purpose read well; labelField exists in fields; allowedSorts are valid; outbound list references real schemas; no inbound entries besides graphRef; joeManagedFields present.
+
+## Notes for maintainers
+
+- Runtime will enrich fields with display/comment/tooltip from the schema when available.
+- Inbound relationships are not hand‑maintained; a graph builder will populate the shared graph later.
+- For core vs instance: `source` is inferred automatically but can be overridden inside `summary` if needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-object-editor",
-  "version": "0.10.508",
+  "version": "0.10.520",
   "description": "JOE the Json Object Editor | Platform Edition",
   "main": "app.js",
   "scripts": {
@@ -38,6 +38,7 @@
     "craydent": "^0.8.9",
     "express": "^4.16.4",
     "googleapis": "^149.0.0",
+    "got": "^14.6.1",
     "jwt-decode": "^2.2.0",
     "mailgun": "^0.5.0",
     "mongojs": "^2.3.0",