Perspective View JSON Loads Through the Hidden Paste JSON Menu

The fix is to skip the zip archive entirely. Create a blank Perspective view, hold Shift, right-click the view in the Project Browser, and select Paste JSON. The Designer rebuilds the view from the clipboard. Hand-editing a view export and re-zipping it fails because the project importer reads the archive's internal resource structure, and pasted text does not change that structure. The sections below build the view up in order. Each one ends with the check that proves it before you move on.

JSON Shape: View Definition vs Component Definition

The term view JSON means the complete serialized definition of a Perspective view. It is an object with the top-level keys custom, params, props, and root. The term component JSON means a single component subtree. It is an object whose top-level keys are the component's own fields, such as type, meta, props, and optionally children and position.

A blank view created with a flex root serializes to this:

{
  "custom": {},
  "params": {},
  "props": {},
  "root": {
    "meta": { "name": "root" },
    "props": { "direction": "column" },
    "type": "ia.container.flex"
  }
}

Shared JSON can be either shape. The shape decides where it gets pasted:

Check 1: Copy the shared text into any JSON validator. Expect the text to parse with no errors, and expect the top-level keys to match one row of the table. Text copied from a web page often carries typographic quotes or trailing characters that break parsing. Replace curly quotes with straight quotes before continuing.

Target View Creation

Paste into a new, empty view rather than a view with existing work. A view-level paste replaces the view's definition, including its params and custom properties.

1. In the Project Browser, expand Perspective > Views.
2. Right-click the destination folder and create a new view. Give it the final name and path you want, because other views and page configurations reference it by path.
3. Accept any root container type. The pasted root object overwrites it with whatever type the shared JSON specifies.
4. Save the project so the view exists as a committed resource before you modify it.

Check 2: Expect the new view to appear in the Project Browser under the chosen folder, and expect it to open on an empty canvas.

Paste JSON Operation

The Paste JSON entry is hidden from the normal context menu. It appears only when you hold Shift while right-clicking. The same Shift+right-click menu on a view also exposes Copy JSON, which is how the shared JSON was produced in the first place.

1. Copy the validated JSON text to the clipboard.
2. Hold Shift and right-click the new view's node in the Project Browser, not the canvas.
3. Select Paste JSON.
4. Open the view if it is not already open.

For component JSON (see the table above), open the target view instead. Then Shift+right-click the destination container in the component tree and paste there. The pasted components become children of that container.

Check 3: Expect the canvas to render the shared layout. Expect the component tree to show the same component names as the meta.name values in the JSON. Expect the Property Editor on the view node to list any params and custom keys from the source. If nothing changes, the clipboard held invalid JSON or a component-shaped object was pasted at the view level. Return to Check 1.

Dependency Resolution After Paste

View JSON carries references, not the things it references. A view that renders correctly on the author's gateway can show errors on yours because of missing dependencies:

JSON from a module's documentation or example pages frequently depends on that module's expression functions. Such a view pastes cleanly, but its bindings fail until the module is installed and licensed on the gateway serving the Designer.

Check 4: Open the Designer output console and select each bound component. Expect no binding errors and no bad-quality overlays. Each remaining error names the missing resource, tag, or function to fix.

Zip Import Failure Mode

A Designer project export is not a JSON file with a zip wrapper. It is an archive of resource folders. Each view is a folder under the Perspective views tree. That folder holds view.json plus a resource metadata file (resource.json) that describes the resource, and usually a thumbnail. The importer places resources according to the folder paths inside the archive. It does not use the zip filename.

The following practices fail, and should not be used:

• Renaming the zip file. This changes nothing the importer reads. The resource path inside the archive stays the same.
• Overwriting view.json inside a fresh export. The resulting archive can import with no visible new resource. The path may collide with the existing empty view, or the metadata may not match the edited content.
• Zipping a loose view.json. Without the resource folder structure and metadata, the importer has nothing to place.

Reserve zip import for archives that the Designer itself exported, unmodified, with the full resource folder structure. For raw JSON text, Paste JSON is the correct path.

Check 5: Delete any stray views created by earlier import attempts, then save. Expect exactly one copy of the view in the Project Browser, at the path chosen in the target view step.

End-to-End Verification

1. Check 6: Save the project. Expect the save to complete with no conflict dialog.
2. Check 7: Shift+right-click the view and select Copy JSON, then compare it against the source text in a diff tool. Expect the structure and property values to match. Only formatting differences, and any edits made during dependency resolution, should appear.
3. Check 8: Enter preview mode in the Designer. Expect bindings to update and any interactive components to respond.
4. Check 9: Add the view to a page configuration, or embed it in an existing page. Launch a Perspective session in a browser. Expect the view to render at runtime with the same layout seen in the Designer, and expect no errors in the session's browser console or the gateway logs.

FAQ