New Bring your own storage. Keep your diagrams in your own private GitHub repository, on Pro and Team.Bring your own storage on GitHub, for Pro and Team. Learn more about bring your own storage

changelog

New features, improvements, and fixes to the Zindex platform.

Week of · 87 changes · Every week

new

diagram_render shows the picture in the chat

In apps that show MCP Apps views, among them ChatGPT and Claude on the web, diagram_render shows the person the saved version's picture in the chat, in a card with the diagram's title and version, Full screen (zoom and pan) and Open in Zindex; an unsaved preview's card shows its PNG. Without preview, a picture too large to send isn't shown and its card links to the diagram in Zindex instead, and a render whose picture can't be read still returns its links. Apps without views, such as Claude Code in the terminal, get the links as before, and section 3 of the privacy policy, updated 2026-11-21, says an app you connect also receives the image of each render.

new

Agents know the person already sees the picture

In an app that shows diagram_render's picture, the result can end with a short note telling the agent the person already sees it, so the agent doesn't attach, redraw or describe it again unless the person asks for a file, a link or a description. With no note, the agent gives the person the svg link as before, as the MCP tools docs and the Zindex skill say.

new

@zindexai/mcp 2.0.1 passes the picture on

The npm package @zindexai/mcp 2.0.1 passes diagram_render's picture on to a host that shows MCP Apps views. Earlier versions pass on only the links, so update the package or remove its version pin.

new

Architecture: Frames stack as layers

Architecture: Write each frame with containerType set to layer, list the layers top to bottom and leave layout off, and the engine arranges them as rows (columns with an LR or RL direction), places each card in its layer, wraps a wide layer onto several rows and runs lines through the layers. Before this, sibling frames stood as separate boxes in a row and a layered picture needed every card and line placed by hand. It applies to architecture diagrams and to a stack inside a generic frame or cloud boundary in an AWS or Google Cloud diagram; a saved stack keeps its places, and autoLayout without elements arranges it again.

new

The dashboard warns before a plan limit

When a workspace reaches 80% of a plan limit, its diagrams on Free or this month's diagram updates or renders on any plan, its owners see a notice on the diagram list and the workspace settings pages. It says what stops at the limit and, below the top plan, what the plan above gives and its price, and an owner can hide it until it has something new to say; at the limit, owners and members see it and it stays. On Free, the diagram list shows how many of the plan's 25 diagrams the workspace holds.

new

Agents get a warning before a plan limit

A create, a saved edit, a restore or a render that leaves a workspace at 80% or more of its limit on diagrams, diagram updates or renders carries LIMIT_NEAR in its warnings, over the REST API and MCP, with the count, the limit and what stops there. It comes on every plan with a number for that limit, names only the limits that call counts toward and says nothing of plans or prices, so an agent can pass it straight on to the person it works for. Render and restore answers, over REST and from diagram_render and diagram_delete with undo, have warnings only when they carry LIMIT_NEAR.

new

Owners get emails near and at plan limits

A workspace's owners get an email when it reaches 80% of a plan limit on diagrams, diagram updates or renders, and another when it reaches the limit, with the count, what stops and until when, and what the plan allows: on Free, the plan above and its price, on Pro, writing to support, and on Team, that each owner or member past the first two raises the pooled limits. For each limit, the near email and the limit email each come at most once a month, limits crossed together share one email, and members and viewers get none. A change of plan or of a team's seats that leaves a workspace near or past a limit, such as a Pro subscription ending with more than 25 diagrams, sends one too, and section 1 of the privacy policy adds the record of which usage emails were sent and when.

new

Connecting an app brings a getting-started email

About an hour after you connect an app such as Claude, ChatGPT, Claude Code or VS Code to Zindex, if your email address is verified and you haven't saved a diagram, you get one short email from Zindex Support with a prompt to try in that app. For those four it adds a tip for the app, such as choosing Allow when Claude asks before it uses Zindex. Each account gets it once, saving a diagram first means it never comes, and replies go to Zindex Support.

new

textStyle.wrap sets how an edge label wraps

An edge takes textStyle with wrap alone, in createEdge, updateEdge and setText: "auto", the default, wraps a label over 200 px, "word" does the same, "character" also breaks a word wider than a line, and "none" keeps one line however long. Nothing is stored unless it is set, so a saved diagram is unchanged except where a label over 200 px that sat on one line is drawn again, in the positions the diagram already has, and wraps; wrap: "none" keeps the old drawing. createEdge and updateEdge refuse align and verticalAlign on an edge, and setText ignores them.

new

EDGE_OFFSET_ON_GROWN_NODE warns of offsets on grown cards

A save that grows a card an edge end pins with an anchor offset carries EDGE_OFFSET_ON_GROWN_NODE in its warnings, and diagram_validate returns it too. It names the width or height the card is drawn at, since an offset is a fraction of the side as drawn, and says to restate the offset against it with updateEdge or to give the anchor the side alone, so the engine places the end. Only an offset on the side that grew is named, and a node whose lines dock on a smaller box than it draws, such as an event or an icon-only card, gets none.

new

ACCENT_COLOR_NOT_DRAWN warns where accentColor draws nothing

A check, save or edit that sets accentColor on an element that doesn't draw it returns ACCENT_COLOR_NOT_DRAWN in its warnings: a plain node, a line, a text, an image, a guide, a group, a Google Cloud zone or an ER entity with no columns. The warning names the elements and what colors that kind of element, such as stroke on a line or textColor on a text, so an agent can set that instead.

new

Architecture: Google Cloud cards can draw as stacks

Architecture: A node with a gcp:* icon takes style.multiple: true and draws a gray copy behind its card, 4 px to the right and 4 px down, as Google Cloud reference diagrams draw several instances of one product. No count is drawn, so write the number in the label when it matters, and every other node ignores the key. multiple is in the published scene and operations schemas, in the open-source spec repository tagged v9.4.0.

new

An example draws a layered architecture from code

The new worked example, Layered architecture diagram from a codebase (layered-architecture-from-codebase), has an agent draw a bike-share platform's five layers from its layer map with no coordinates: 19 cards, a Payments sub-group and 21 lines, two of which skip a layer. It has the prompt, the diagram, the example's own preview card and the edits that change it, for adding a card to a layer, moving a card to another layer and reordering the layers.

improved

Nodes stay clear of text, images and frames

On a new diagram, and for autoLayout without elements, a drawing that would land over a text, an image or a frame you wrote at absolute coordinates moves right or down by the least distance that clears it, keeping the node spacing. It covers flowchart, workflow, architecture, ER, UI flow, org chart, network, AWS and Google Cloud diagrams, except a sequence diagram, a pool or lane with its own box, nodes you positioned yourself and elements the nodes are members of.

improved

Sequence diagram: Untyped edges and notes are drawn

Sequence diagram: An edge between two participants with no sequence type is drawn as a message: a reply when its line is dashed, an async message when it is solid with an open arrowhead, and a call otherwise. Before, it was drawn outside the message rows. A note with no anchor is drawn over the lifelines of the message above it, or beside them with side, where before it was left out of the picture, and FAMILY_SEQ_NOTE_INVALID_ANCHOR now says what is drawn.

improved

A frame's accentColor colors its border and title

A frame's accentColor draws its border and its title, the title in a shade that reads at 4.5:1 in every theme, where before it drew nothing on a frame. stroke, textColor and fill still override it, and the accent adds no fill.

improved

A save stores each card's drawn size

A create or an edit saves the size each card is drawn at, so layout holds what is drawn, where a card whose label needs more room than the width written for it was drawn wider while the saved layout kept the narrower number. An agent that reads the layout, or works out an anchor offset from it, now gets the drawn size, since an offset is a fraction of the drawn side, and changed lists a card saved at a new size. Reads, renders, validates and restores write nothing, saved revisions are not touched and an older diagram records its sizes on its next save; events, gateways, UI-flow entry and exit nodes, icon-only nodes, cards a Google Cloud zone spans and stacked Google Cloud cards keep their stored size as before.

improved

An edit keeps a card you sized by hand

An edit to a label or an icon no longer shrinks a card you sized by hand: a size larger than the old content needed is kept, and a card the engine sized still follows its label. This goes by the saved size, so a hand-sized card exactly as big as its content follows it too, and autoSize: "none" has always meant the written size is a floor, not an exact size.

improved

Architecture: Edits keep a stack of layers

Architecture: A card you add to a layer, or move into one, stands in that layer's row, where before the diagram's general rules placed it, and a layer that grows for it, or is added, moves what lies after it along by the growth. autoLayout without elements arranges the stack again, and with elements puts the named cards back in their layers. A layer you create with createFrame goes last and a card with no layer goes by the general rules; to reorder layers, delete them and create them again in the new order with their cards in children, then send autoLayout without elements in the same edit, which moves every node.

improved

Side-only anchors leave the place to the engine

An anchor with a side and no offset fixes the face and leaves the place on it to the engine, where before a side alone still held the end in place and could force a detour. Where two facing sides overlap the line comes out straight, ends that share a side spread apart, and a line that would cross a frame's title slides along the overlap past it. An offset still places the end, as a fraction of the side as drawn, and a BPMN sequence flow or UI-flow transition into a node keeps its centered entry unless its ends are within 16 px of center (a side alone fixes only the face there).

improved

Long edge labels wrap onto several lines

In every diagram type with edge labels, a label wider than 200 px wraps onto several lines, so a long label no longer sprawls across the diagram, and a label of 200 px or less is drawn exactly as before. It breaks where a node's label breaks (at spaces, after hyphens and slashes, and between Chinese and Japanese characters); a \n still starts a line, a transition label written as EVENT [guard] / action breaks between its parts first, and an identifier with no break point stays whole. The layout leaves room for a wrapped label: a flow left to right reserves its width between ranks, one top to bottom its height, sequence rows grow by its height and a self-message loop widens.

improved

Labels find a clean place 1 px wide

When no place the label placer first tries along a line is clean, it tries each place 1 px apart, so a label finds a clean place as narrow as 1 px instead of landing on a line or a border. This applies to every diagram type.

improved

Crowded edge labels wrap narrower to fit

In every diagram type with edge labels, a label with no clean place at its measured width, one that would cover a node, another line, another label or a frame's border, is tried wrapped narrower, onto two or three lines, and takes the widest width that finds a clean place. A label that already has a clean place never changes, and textStyle.wrap set to "none" on the edge keeps a label on one line. A label of 100 px or more is tried, and a shorter one only where its best place would cover something or cross a frame's border; a label that can't break and a sequence diagram's messages are left as they are.

improved

Labels stay by their lines, knockouts spare nodes

In every diagram type with edge labels, when labels are separated from one another or from the leg of a loop-back line's U-hook, a label moves no more than 14 px off its own line, and is never stepped onto the gcp.cloud boundary's blue or into a frame its line only passes through, where before it could end up 32 to 49 px across its line, on whatever lay there. A label that covers another label still steps off it, even past 14 px. Where only a label's padding would touch a node, its background knockout stops 1 px short of the node, so it no longer bites the node's border.

improved

Parallel lines spaced by their labels' height

In flowchart, workflow, UI flow, architecture and entity-relationship diagrams, except an AWS or Google Cloud diagram the cloud layout arranges, parallel lines between two nodes in neighboring ranks are spaced by their labels' height on a new layout and for nodes an edit adds, where a wrapped label is taller than the room between them. State-machine diagrams with long transition names are the visible case.

improved

Limit cards say what the plan above gives

Where a plan limit stops something in the dashboard, such as creating an API key, restoring a deleted diagram or saving in the playground, the card tells an owner who can upgrade what the plan above gives, with its price. Dashboard > Usage shows each reached limit's next step: upgrading below the top plan, otherwise when the limit resets or asking an owner.

improved

The privacy policy says what connected apps receive

The privacy policy, updated 2026-11-17, says what an AI app you connect with your sign-in or API key, such as ChatGPT or Claude, receives: what its calls ask for in that workspace, including who saved each version, by name or email address, and with which app, while Zindex sends your diagrams to no AI provider of its own. Section 1 lists what a diagram holds (its title, key, brief and every version with its edit message), says every version is kept until the diagram or its workspace is deleted, and adds the image links a render makes, which anyone who has them can open for 7 days without signing in. The privacy policy and the terms say Zindex isn't directed at children under 13.

improved

Agents learn which pages can load live pictures

The diagram_render description, the Zindex skill and the MCP tools docs say a page you publish loads a version's picture live, calling diagram_render as it opens, only where the page can call Zindex tools. Where it can't, and no command can run to embed the version's PNG, the skill has the agent give the version's page link alone.

improved

MCP internal errors say to email support

When an MCP tool answers INTERNAL_ERROR, its error says to try again and, if it keeps failing, to tell the person to email support@zindex.ai and say when it happened, where before it named the request's ID. Every response still carries the X-Request-Id header, and the REST API's INTERNAL_ERROR still names it in its error.

improved

Architecture: Google Cloud labels keep clear of lines

Architecture: In a Google Cloud diagram, an edge label keeps 10 px from other lines and from every card but its own line's ends, and sits at least twice as near its own line as to any other, where there is room. Where no clear place at its width has that room, the label takes the widest narrower wrap that does, and it stays out of a frame's title row so it doesn't read as part of the title. Other diagram types, AWS included, place labels as before.

improved

Architecture: Dashboards stand below the Regions

Architecture: In a Google Cloud diagram, a Looker or Looker Studio dashboard that a party outside calls goes below the Regions when the lines the Regions send it match the lines it sends them plus the calls from outside and every card feeding it ends its Region's flow, so the line from the warehouse runs down. A user who only calls such a dashboard stands below the boundary with it, so an analyst drawn with a user icon no longer needs another icon to stand there. A user with a line to any other item of the boundary stays above, and a saved diagram keeps every item's place.

improved

Architecture: Regions keep 24 px under their cards

Architecture: A Google Cloud Region keeps 24 px under what it holds: its lowest card, row of items or subnet. A diagram saved before this is drawn with its Region frames, and the rows under the Regions, a little lower, with no node inside a Region moving.

improved

Architecture: Rows stand aside from lines through them

Architecture: In a Google Cloud diagram, a line from a party outside the boundary or a global item that drops through a project's own row of items, or through the row gcp.cloud lists, makes the row stand aside: the items in its way move 16 px clear and the row keeps its order. A line that runs level across a card can't be stood aside from, so the router draws an orthogonal line round the cards, and it crosses a card only where no route round the cards exists; check the image there. A saved diagram moves no saved card, and autoLayout makes the row stand aside.

improved

Architecture: Project titles move clear of lines

Architecture: A Google Cloud project's title moves from the top center to the top left when a line from an item above into a card under it would run down within 16 px of it, so the line runs straight and its label doesn't read as part of the title. A title stays centered where a line would be in the way at the left too, or when the project is no wider than the title needs. An edit that adds or removes such a line can move the title, since a save stores no place for it.

improved

Architecture: Region gaps open for a line's label

Architecture: A labeled line that runs straight between matching rows of two neighboring Google Cloud Regions opens the gap between them to hold its label, so the label stands on the line between the borders instead of across both Regions' cards. The gap stays as it was for a line between different rows, past a card, past a Region or into a Region with no subnet. An edit that labels such a line moves the second Region and what lies right of it further right, and no card within a Region moves.

improved

Architecture: Region cards stand in rows by flow

Architecture: A Google Cloud Region that lists many cards directly, such as Cloud Run services with no tiers, no longer draws them in one very wide row. Past 1,400 px the cards stand in rows by flow: each card one row below the lowest card that has a line into it, cards no line joins last, and within a row the order is chosen to cross fewer lines. The subnets and tiers are unchanged and a narrower Region draws exactly as before; an edit never reorders saved cards, and a new card joins the row after its lowest caller.

improved

The trial-ended email covers near limits and renders

When a team's free trial ends with nobody subscribed, the email its owners get names each of Free's limits the team is near or past, renders included, in the same words as the usage emails, where it named only diagrams and diagram updates at or over the limit. No usage email repeats a limit that email named.

improved

Architecture: Lines of different looks take separate ports

Architecture: In an AWS or Google Cloud diagram, lines that differ in color, width, dash or opacity and leave or enter one card or icon on the same side take separate points on that side, 12 px or more apart (13.6 px in Google Cloud), and tracks of their own, where one color drew over the other on a shared stretch. Lines drawn alike still share a port and fork with a dot. A line with an anchor, a straight or curved edge, a line that runs straight between two facing cards and a side too narrow even for half the gap keep the shared port, and other diagram types (ER, org charts, state diagrams and plain architecture diagrams) are unchanged. In a Google Cloud diagram, where a global item's lines run as a trunk into two neighboring Regions, the gap between the Regions opens by a port gap for each extra way its lines are drawn, so each line stays clear of the Region borders.

improved

Architecture: Cards that stand together share a width

Architecture: In a Google Cloud diagram, cards that stand together are drawn at one width in a new layout and after an autoLayout without elements: cards in one row of a subnet, or in one frame such as a GKE cluster. Cards of one product whose labels need nearly the same width (within 24 px) share the widest one, and any two cards within 8 px do; cards of different products more than 8 px apart keep the width their label needs. Zoned cards and style.multiple cards keep their own rule; an edit leaves the width of a card it doesn't change, and a card it adds outside a zone column takes the width its own label needs.

improved

Architecture: Lines keep out of narrow border strips

Architecture: In a Google Cloud diagram, a line takes a clear channel instead of running down the narrow strip between a Region's border and its subnet's border, when the detour costs less than the run it saves.

improved

Architecture: Facing cards' straight line avoids drawn lines

Architecture: In a Google Cloud diagram, when two cards face each other but aren't centered on one another, the straight path between them is not taken across a line already drawn. The line takes another route. Other diagram types are unchanged.

improved

Architecture: Google Cloud lines cross each other less

Architecture: In a Google Cloud diagram, a failover and a replication that leave one card's face and come back to two other cards nest, so neither crosses the other. An orthogonal line that crosses another is routed again with its faces left free, and the new route is kept only when the finished diagram crosses less. AWS diagrams are not routed again for crossings.

improved

Architecture: Frame lines run in a lane past cards

Architecture: In a top-to-bottom Google Cloud diagram, a line from a card of a frame laid out as a block, such as a GKE cluster or a service perimeter, to a card outside it, with another card of the frame in its way, runs in a lane beside or under the frame's cards, at least 16 px off the cards and the border, and leaves its card by the face on the lane's side, where before it could run along the border and cross other lines. Two lines down the cards that would cross in one lane take the two sides, and the frame is sized so the lane fits. No lane opens for a line to the frame itself, for a card whose face toward the other end is free, or in a diagram that doesn't flow top to bottom; zoned cards and AWS diagrams are unchanged, and a saved diagram keeps its frames and cards, so a lane opens only in a new layout or after autoLayout without elements.

improved

Architecture: Lines to a frame clear its title

Architecture: In a top-to-bottom Google Cloud diagram, a line from an item above that ends on a generic frame laid out as a block, such as a GKE cluster, lands on the frame's top 16 px clear of its title, where it can still drop straight under the item. The lane a frame keeps over its cards for a second line past them runs 16 px under the title too, and the frame's top grows until it does, in a new layout or after autoLayout without elements. Where the title leaves no such place, or the item has other lines down, the line lands where the router puts it.

improved

Architecture: Outside lines cross the blue straight down

Architecture: A line from a party outside the gcp.cloud boundary into a global item crosses the boundary's blue straight down, where before it ran a long way along it. Where the party doesn't stand over the item, the line shifts sideways in the gap above the boundary. In a new diagram that gap opens to hold these lines and their labels.

improved

Architecture: A shared sign-in service stands near callers

Architecture: A service that parties outside the boundary call, and a Region calls too, such as a sign-in service, stands in the boundary's top row near its callers. The outside party's line is a short drop, not a line round the whole boundary.

improved

Architecture: Delivery-only parties stand below the boundary

Architecture: In a Google Cloud diagram, a party outside the gcp.cloud boundary that only delivers to a landing bucket in the row below the Regions, such as a partner's SFTP drop, a courier feed or a data source, stands below the boundary near the bucket, so its line is a short straight rise, where it ran down the boundary's side. A party that also has a line to or from anything above the bottom row, or that is joined to a party that stands above, stays above. A party drawn with a user icon (gcp:user, gcp:users, aws:user, aws:users, lucide:user or lucide:users) stays above when it sends more lines in than it gets out. A saved diagram keeps every item's side, autoLayout stands a party below the boundary when it qualifies, and an edit that adds such a party places it below; other diagram types are unchanged.

improved

Architecture: Outside frame members follow their targets

Architecture: The members of a frame outside the boundary stand left to right in the order of the items their lines go to, so the lines leaving the frame no longer cross just under it.

improved

Architecture: Lines past the subnets get room

Architecture: A line that runs past the subnets, such as a nightly export to a database below them or an outside party's line to such an item, keeps its distance from the VPC band's border. In a new diagram the gap over the band and the gap under it open to give the line that room.

improved

Architecture: Edge labels keep off Google Cloud's blue

Architecture: Edge labels take any clear place off the gcp.cloud boundary's blue, where before one could land on the header band in the line's own dark color and be hard to read. Where a line has no place off the blue, its label stays on it, drawn at 4.5:1 contrast in its own hue, so a dark orange becomes a dark brown. A label with its own labelBackground, or on a boundary whose fill the scene sets, is drawn as before.

improved

Architecture: Lines stay readable on Google Cloud's blue

Architecture: A line's stretch on the gcp.cloud boundary's blue that is hard to read, such as an orange, green, blue or purple set in style.stroke, is drawn darker at its own hue, to 3:1 against the blue. A line that already reads at 3:1, as the default near-black does, and a line on a boundary whose own style sets fill stay as written. Section 5.5 of SPEC.md in the open-source spec repository, tagged v9.4.1, states the rule, and no input field or value changes.

improved

Architecture: The Google Cloud example stacks its buckets

Architecture: The "Dual-region buckets" card of the Google Cloud example (gcp-architecture-from-terraform) is a stack with style.multiple: true in both revisions, since it stands for every bucket in the dual-region. Its Terraform gains an access-logs bucket in the same dual-region, which adds no line because both buckets are in the card. The card's box is 4 px wider and taller for the copy, and the pictures are drawn again.

improved

Architecture: Outside lines go round the Regions

Architecture: In a Google Cloud diagram, a line from a party outside the gcp.cloud boundary to an item in the row below the Regions prefers a way around each Region it neither starts nor ends in, where before it ran down through the Region past a card. A Region is a cost, not a wall, so the line still crosses one when going round is far longer. AWS diagrams keep their own rule.

improved

Architecture: A global item's drop leaves by the bottom

Architecture: In a Google Cloud diagram, when the straight drop from a global item into a card's top would stand under 16 px from the item's own side, the line leaves the item's bottom instead, so it no longer runs close along the item's edge.

improved

Architecture: Group titles keep lines' tracks clear

Architecture: In an AWS or Google Cloud diagram, every group title, not only one that carries an icon, bounds the tracks of lines that part at a card, so a track isn't spread onto a group's title.

improved

Frame messages name the operation to use

In an architecture diagram with sibling generic frames, NODE_OUTSIDE_FRAME and NODE_IN_WRONG_FRAME tell an agent to set containerType to layer on each frame with updateFrame, then send autoLayout without elements; the first frame listed is the top row. An updateFrame error for a box property such as position, size or layout names moveElement to move a frame with its cards and resizeElement to resize it.

fixed

Text and images keep written coordinates

A text or image with an absolute layout at coordinates from 0 on stays exactly where you wrote it on every layout, autoLayout included, and a frame with its own absolute layout is no longer shifted by the first layout of a diagram that also has nodes. Before, that first layout moved them with the rest of the drawing, so a note sat in the wrong place and saving the diagram moved it again. A frame's layout can still move where making room needs it, and autoLayout without elements still takes it off every frame but a pool, lane or fragment (org charts and networks keep frame layouts).

fixed

Deleting and sharing diagrams work in ChatGPT

In ChatGPT, deleting a diagram, publishing it, making a share link, reporting a problem and sending feedback (diagram_delete, and diagram_share with publish, link, report or feedback) run on the call the person approves in ChatGPT's own prompt. Before, Zindex asked for its own confirmation after ChatGPT had asked, and ChatGPT never sent the confirmed retry, so these actions never completed from ChatGPT. A person who chooses to always allow Zindex in ChatGPT isn't asked again before any Zindex call, in any chat, as Confirmation, at zindex.ai/docs/tools/#confirmation, describes; Claude Code keeps its yes or no form, and other apps keep the CONFIRMATION_REQUIRED step.

fixed

The line to paste ends with the URL

The line to paste into your agent, on the homepage and at zindex.ai/connect, reads "Read https://zindex.ai/skill/SKILL.md, then connect to Zindex's MCP server at https://api.zindex.ai/mcp", with nothing after the URL. Before, the line went on past the URL, so copying from the URL to the end into a connector's URL field, such as a Claude custom connector's, saved an address that isn't the MCP server, and the connector never worked. To repair a connector saved that way, remove it and add it again with https://api.zindex.ai/mcp as its URL.

fixed

Architecture: A new layer stack clears pinned cards

Architecture: A stack of layers none of whose cards has a layout, drawn beside pinned cards such as clients, is arranged as a new layout arranges it and stands a gap clear of the pinned cards, 56 px or layoutStrategy.nodeSpacing when that is larger. Before, the general rules placed each card by its neighbors, and a first save returned NODE_IN_WRONG_FRAME and FRAME_OVERLAP_DETECTED warnings. The pinned cards stay where they are, and a layer with a layout of its own divides the stack into the layers listed before it and the layers listed after it; a stack with a card that already has a layout goes by the rules for edits to a stack of layers.

fixed

Architecture: Layers keep room for their titles

Architecture: In a stack of layers drawn as rows, each layer keeps room for its title left of its top row's first card, so a line into that card from above enters the top face at least 16 px clear of the title, where before it could enter a side face from outside the frame. A long title never changes where the line enters, and it widens every layer, since the layers share one width. A saved stack whose top row's first card stands nearer a layer's left edge than the title needs is drawn with its layers wider to the left on any draw, and no card moves; a stack of columns (LR, RL) keeps no such room, since its titles stand above the cards.

fixed

Architecture: Lines between cards stay inside the stack

Architecture: In a stack of layers, a line between two cards of the stack stays at least 16 px inside the stack's left and right borders (top and bottom in a stack of columns), where before a line that skipped a layer could leave through a passage outside the stack's frames and enter a card's side from outside. A layer such a line passes through without ending in it keeps at least 32 px between the frame fitted around its cards and the stack's right border (the bottom in a stack of columns), and every layer widens to give it unless another layer already reaches that far; a saved stack with such a line is drawn with its layers wider on the right on any draw, and no card moves. A line with a card outside the stack at either end isn't held between the borders and a line from a card to a layer isn't covered, and the gaps between a row's cards can still be narrow, so a line can pass close to a card's side.

fixed

Architecture: Outside lines no longer block a save

Architecture: A Google Cloud diagram with two or three parties outside every frame, each with a line into a card of a Region, saves and draws every line. Before, a create, or an autoLayout on a saved diagram, failed with an internal error and saved nothing. This fixes the failure to save and moves no card: a diagram that saved before is drawn as it was, and in some of these diagrams two cards of a Region, such as the edge security policy and the load balancer, can still stand touching.

fixed

Architecture: Items beside the load balancer never touch

Architecture: In a Google Cloud diagram where parties outside the boundary have lines that drop through the row of the global load balancer, the load balancer keeps its place over the gap between the two Regions, and an item of that row, Cloud Armor for one, stands beside it, or over it where no room beside it serves, layoutStrategy.nodeSpacing clear (30 px by default). This follows the fix that lets such a diagram save, after which two items of the row could still stand touching with no gap; on a new layout they never do. It covers a load balancer that feeds the first tier of each of two neighboring Regions, and one that feeds a single Region has no gap to keep, so its row stands aside from the lines as before. A saved diagram keeps the gap it was saved with, touching items included, until autoLayout, and only a top-to-bottom flow is tested.

fixed

Lines keep clear of the nodes they pass

A line that ran along a node's side, a fraction of a pixel off it, keeps 16 px off the side, or runs down the middle of a gap between nodes less than 32 px apart. A line crosses a node it doesn't end on only where no route round it exists, and EDGE_OBSTACLE_GRAZED reports it. An end set with anchor and every straight or curved edge stay as written.

fixed

Lines keep off the sides of their own cards

A line's run along the side of the card it starts or ends on no longer lies against the card's edge, where it read as part of the card's border. Where there is room it keeps 16 px off the card, in every diagram with orthogonal lines and most often in architecture diagrams, and a fan-out's branches stay where they are. A line that can't clear a card's side by 8 px is still drawn and reported as EDGE_OBSTACLE_GRAZED, which the API does not return, so check the image.

fixed

Close line crossings share one frame gap

Two lines that cross a frame's border less than 16 px apart share one gap, so no stub of border is left between them. This holds in every diagram type that draws border gaps; pools, lanes and sequence fragments keep their own drawing.

fixed

A crowded label no longer covers another line

A label with no place free of lines keeps its text off them, and its background stops short of a line it only grazes. In an entity-relationship diagram, a relationship label that had no clear place no longer covers another relationship's line, and in an architecture diagram one label moves off a dashed line.

fixed

ER diagram: A self-loop join gets a junction dot

ER diagram: A line that joins a self-loop gets a junction dot where the two part, so the join no longer reads as a crossing.

fixed

Dark and sketch themes mute guards and actions

In the dark and sketch themes, the [guard] / action part of a transition label written as EVENT [guard] / action reads quieter than the event, as it does in the default theme. Before, only its smaller size and the action's italic set it apart.

fixed

Architecture: Google Cloud projects no longer overlap

Architecture: A Google Cloud project that holds its own global item, such as a shared VPC host project with a load balancer next to its service projects, is no longer drawn over the next project. Each project is one box: its items stand in a row of their own over its Regions, inside the box; a row wider than its Regions makes the box wider, the Regions after it stand further right, and projects at one level share a line for those rows. The boundary's own items stand over every project, and a load balancer feeds the Regions of its own project, so to draw one over several projects, list it in gcp.cloud. A saved diagram keeps its places until autoLayout; a new item an edit adds to a project is placed within the project's width, and the next project moves over by the growth.

fixed

LIMIT_NEAR says plainly when a limit is reached

LIMIT_NEAR on the call that reaches a limit says the workspace has reached it and what stops until when: at Free's 25 diagrams, new diagrams can't be saved, and deleted ones can't be restored, until it has fewer than 25, where it said "25 of its 25 diagrams" as if the limit were still ahead. Below the limit, the diagrams warning names restores too. The render warning for agents and the dashboard's render notice say that rendering saved diagrams stops at the limit while unsaved previews and image links keep working, where they said rendering stops.

fixed

Untyped group warnings match a group's own name

GCP_GROUP_UNTYPED and AWS_GROUP_UNTYPED warn only when a generic frame's title is a group's own name, alone or with one identifier, such as "VPC network" or "Region: us-east1". A title such as "VPC Service Controls perimeter" no longer gets the wrong gcp.vpc advice, and the message says to set the type if the frame is that group "or leave it generic". An AWS frame titled "Subnet" is told about both subnet presets.

fixed

Architecture: Lines keep off Region and VPC titles

Architecture: In a Google Cloud diagram, a line no longer runs through a Region's title or the VPC band's title, and the router routes round the VPC title. A Region with no subnet reaches out on its title's side when the lines into its card from a global item above the Regions would leave the card's top no place clear of the title, so they land clear of it and a port's gap apart; the band's margin before its first Region opens for each line that runs down beside the Regions between an item above the bands and one below them, so those lines keep their distance from the VPC title, from each other and from the Region's border. A new diagram opens these gaps, and an edit that adds such a line grows the Region or the band the same way, moving what lies past the growth by it; a straight or curved edge keeps its one segment and can still cross a title, as can an orthogonal line where the router finds no route round it.

fixed

Architecture: Lines no longer show through labels

Architecture: In a Google Cloud diagram, a label on the gcp.cloud boundary's blue with its own line running under the text has an opaque backing in the blue, so a faint stripe of the line no longer shows through the letters. A label beside its line, or off the blue, keeps its usual 90% backing.

fixed

Architecture: Failover labels clear of replication lines

Architecture: When a card stands between a primary and its replica in a Google Cloud tier, such as a standby, the replication line runs under the tier's cards, below the room the tier keeps for the labeled failover. The failover's label no longer sits on the replication line or straddles borders, and the tier is deeper in every Region of the row. In an existing diagram, adding a card right of the standby deepens the tier the same way and moves what lies under it down by that growth.

fixed

Architecture: Google Cloud arrowheads no longer touch

Architecture: Two arrowheads side by side on one face in a Google Cloud diagram sit at least 13.6 px apart, so their wings no longer touch. Other diagram types keep 12 px, and a face too short for its ends still packs them closer.

fixed

Architecture: A growing card pushes the rest once

Architecture: In a saved Google Cloud or AWS diagram, when an edit makes a placed node bigger, such as a longer label or a Google Cloud card that becomes a stack, everything past it moves by exactly the growth, once. Before, it moved by two or more times the growth, so rows came out of line across zones or Regions. A diagram laid out from scratch draws as before.

fixed

Architecture: Wide tier titles no longer cross lines

Architecture: A Google Cloud tier whose title is wider than its first card no longer has a line from a row above run through the title. The Region's tiers reach out on the title's side until the card clears it, so the line into the card stays straight, and a line from outside the boundary causes no reach. In an edit the frames grow the same way, and with two Regions what lies past the growth moves by it, an exception to updateFrame keeping positions that SPEC.md 6.4 and 10.4, tagged v9.4.2, state.

fixed

Architecture: Lines past a tier get a lane

Architecture: A Google Cloud line that leaves a tier, a node of a subnet's own row, or a card when the item is below, and runs past another tier to an item above or below the subnets, drops straight into the item from its own lane 16 px outside the tiers, where before it ran down the subnet's narrow inset against both borders or along a tier's border in the gap between two tiers. The inset and the gap open for the lane, several lines on one side run 16 px further out each without crossing, one item per side gets a lane, and a line up from a card inside a tier, or to a second item, is left to the router. In an edit, saved lines keep their places and the new one runs outside them, the rows under the gap move down by its opening, what lies right of the subnet moves right by the growth, and a node below the subnets that the line feeds moves under it.

fixed

Architecture: Tier lines drop straight down a gap

Architecture: A line from a tier to a node of a subnet's own row, such as a cache, past another tier now drops straight down a gap between zone columns, where before it ran down through the tier between and grazed both cards. The gap opens through every Region and the node stands under the line; in an edit, what lies right of the gap moves right by the opening. This needs two or more zone columns with every card in a zone, and without them the router draws the line.

fixed

Architecture: Outside lines drop into lower tiers

Architecture: In a top-to-bottom Google Cloud diagram, a line from an item outside the boundary, such as an on-premises data center, into a tier past the first tier of a subnet drops straight down a lane of its own onto the tier's top, a gap between the zone columns or a lane beside the tiers on the right, where before it ran round the Region's side along two borders and ended beside the tier. It applies when every line the item has needs the lane and all lead into one Region, one item to each gap; a curved edge and any other line are drawn as before. A saved diagram is not redrawn, but a line added from a saved item that already has lane lines takes the lane away from that item's lines, and the router draws them.

fixed

Architecture: Line ends keep apart and clear

Architecture: In a Google Cloud diagram, two line ends closer than 12 px on one face are parted, so two lines no longer read as one. An end leg the engine moves keeps 8 px or more from other cards and from frame borders, and no longer slides a line along a card's side. An anchor with an offset, a straight or curved edge and a self-loop keep their places.

fixed

Architecture: Labels no longer sit on their lines

Architecture: A labeled line between two cards of one tier runs its drop under the zone strips with its label under it, so the label no longer sits on the line. A line that crosses a labeled run no longer splits it into halves shorter than its label, which left the label over the line. A label wider than its line still hangs out past it, so keep labels short.

fixed

Cloud group borders stay visible in dark previews

In a dark preview, the border of an AWS or Google Cloud group keeps the contrast it had in the light design, up to 3:1, where the scene sets a fill on the group or under it. Before, the preview adapted that fill to the dark canvas and left the border in its provider's color, so a Google Cloud boundary filled white, as agents often write it, nearly lost its outline. A gcp.cloud boundary left blue, and a group with no scene fill on or under it, draw as before.

fixed

Architecture: A tier's line enters an item's top

Architecture: A line from a Google Cloud tier to an item standing under it, such as a storage bucket or a function below the Regions, enters the item's top wherever no node stands between them. Before, it entered the side facing the line, which left a short cramped branch with no room for its label. A card's own line keeps the facing side.

fixed

Architecture: Outside parties enter the load balancer's top

Architecture: A line from a party above the gcp.cloud boundary, on its own or in a frame outside it, to a global item above the Regions, such as the global load balancer, enters that item's top, not its side beside a neighbor card. The end lands off center where a drop into the middle would cross a title, and two lines into one top come in at least 12 px apart. A global item below the Regions, and a party not above the boundary, keep the side the router picks.