Saving and publishing

Read the save status before leaving the editor. Saved tells you whether storage has the change; Public/Hidden describes the entry’s visibility. Publishing and deploying are separate steps on a static site.

Where a save goes

For inline text, images, structure, and Studio fields:

Site configuration	Where the save goes
Server delivery without an authorization policy	Shared content; live on a new request
Static delivery	Private draft until Publish
Any delivery with an identity authorization policy	Private draft until Publish

Markdown body edits always save as private drafts and require Publish, in both server and static delivery.

In draft workflows, Publish moves the current editor’s saved drafts into shared content. On static sites, visitors see the previous build until the new content is rebuilt and deployed. Server caches may also need invalidation.

Read the status

Status	What to do
Unsaved changes	Save or finish the inline edit; this work is still in the browser
Saving	Wait for completion before navigating away
Draft saved	Work is stored privately; Publish when ready and permitted
Changes are live	The save reached shared content
Save failed or conflict	Keep the current page open and follow recovery guidance
Deploying / Deploy failed	Content may already be published; check the deployment separately

A successful webhook response confirms only that the deployment service accepted the request. Deployment status can verify that the build contains your published commit or revisions.

Edit and Preview

Edit enables click-to-edit controls. Preview hides editing controls so you can browse and follow links. Switching modes preserves work and does not publish, discard, or switch your private content into public content.

To check what visitors see, open the deployed site in a signed-out session. In static authoring, your editor view includes drafts while visitors see the last deployment.

Public and Hidden entries

Configure a publication field in the collection’s schema and settings:

caret({
  schemas: {
    posts: {
      type: 'object',
      properties: {
        title: { type: 'string' },
        published: { type: 'boolean', default: false },
      },
    },
  },
  collections: {
    posts: { publication: { field: 'published' } },
  },
});

Public Caret reads return only entries whose configured field is exactly true. Authenticated editors can still see hidden entries. Your templates must use Caret’s content reads/loader for that filtering; the setting is not access control for arbitrary Astro routes or unrelated data sources.

In a draft workflow, changing this switch remains private until Publish. With direct server saves, saving the switch changes shared visibility immediately. Hiding an entry keeps its data; deletion is a separate action.

Discarding and signing out

Discard removes saved draft changes without publishing them. The toolbar operates on all of your drafts; custom clients can use a scoped discard through the API.

• A stable external identity can reopen its saved drafts after signing in again. The sign-out dialog offers Keep drafts and sign out.
• A shared-password login creates a session-specific draft identity. Signing out makes that session’s drafts inaccessible. The dialog offers publication, discard, or cancellation instead of promising future access.
• Unsaved browser edits are not saved drafts. Resolve them before leaving.

Git commit on publish

For filesystem or Markdown storage, CARET_GIT_ON_PUBLISH=true attempts a local git commit of the content root after publication. The root must be tracked or trackable: a gitignored .caret/data folder is not committed automatically. Git failures do not roll back published content. This option does not push the commit or deploy your site; arrange those steps in your workflow.

Next: publish conflicts and recovery, static delivery, or permissions.