Share Artifacts (publish local files and pasted content as links)
Share Artifacts turns a local file, or HTML / Markdown / Text / React you paste into a modal, into a public shareable URL in one click: a self-contained page at https://shares.omniscio.com/s/<token> that any browser opens with no account or extension.
On this page
What it is
Any local file — or HTML / Markdown / Text / React you paste into a modal — becomes a public shareable URL in one click: a self-contained HTML page at https://shares.omniscio.com/s/<token> that any browser opens to a styled view of the original content, with no account or extension (images render inline, PDFs embed with a viewer, code gets syntax highlighting, markdown renders in an Omniscio-owned document preset with headings / tables / light-dark theming, plain text gets monospace formatting, HTML and React run live with JS execution just like Claude.ai's artifacts). Framed artifact share pages (text / code / markdown / paste) include a Light / Dark toggle in the header — the viewer's choice persists in localStorage across reloads. Full-bleed HTML / React / image shares carry no toggle: their content renders inside a sandboxed page (or a viewport-filling image) the toggle can't re-theme — instead those pages take their light/dark from the artifact itself. The shell reads the page's own declared color-scheme (or its root background) and matches both the backdrop and the native scrollbar (and form controls) to it, so a dark share shows a dark scrollbar (and never flashes white) on every device — inside the app and on any OS — instead of the browser's default bright bar; an artifact that declares no theme falls back to the OS-following light dark. Framed shells still bind their color-scheme to the Light / Dark toggle.
This is distinct from Artifact Sharing (sessions / messages / selections — see artifact-sharing.md). That feature takes conversation content and turns it into HTML. Both feed the same share_links table and the same https://shares.omniscio.com/s/<token> URL space, but the entry points and supported inputs are different.
Three in-app entry points exist today:
- File peek toolbar — open any file in the Peek viewer (click a file path in an agent message, or use the in-app file browser), then click the Share2 / Publish icon in the toolbar between Copy and Edit. The current file's absolute path is sent to the publish pipeline; the resulting URL lands in your clipboard.
- Paste publish modal — Settings → Sharing → Publish pasted content button. Opens a modal where you paste arbitrary HTML / Markdown / Text / React, pick a content type, an optional Title (the page heading) and Subtitle (the field formerly named "Label"), an optional lifetime from the shared list (1 hour / 24 hours / 7 days / 30 days / 90 days / 6 months / No expiry — leaving it alone publishes a 30-day link, and a link only has no expiry when you pick No expiry), and — for HTML / React — an optional Full-screen toggle plus a backdrop-colour box, then hit Publish. Omniscio stages the text under
<userData>/published-pastes/<uuid>.<ext>, runs the same validation pipeline as the file path, uploads to Firebase, and copies the URL to your clipboard. (See Presentation controls below.) - Chat-link right-click menu — when Claude produces a file path in a chat message (e.g.
[notes.md](docs/notes.md), an attachment chip the user previously dropped into the conversation, or any other markdown link to a file inside the project), right-click the link to open a small portal menu. Below the existing Copy path item is Share as public artifact — pick it and Omniscio publishes the file straight through the same pipeline as File Peek, copying the URL to your clipboard. A file already inside the share allow-list publishes with no prompt; one outside it needs a native OS confirmation first. File paths resolve through the active session's worktree (or project folder); attachment links (attachment://<sessionId>/<filename>) resolve through the main-process attachment store so the renderer never has to know the userData absolute path. Virtual-project links (__inbox__, etc.) cannot be resolved and surface a friendly error toast — paste the content through the paste modal instead.
A fourth entry point, the CLI control server's POST /share/publish, is documented at share-cli.md.
What gets uploaded
For every successful publish, Omniscio:
- SHA-256-hashes the raw bytes of the source file PLUS the presentation knobs (
title/fullBleed/background, plus the free-tier "Made with Omniscio" badge state). This is the dedup key — if the same content with the same presentation has already been published in an active share row, the existing token / URL is returned withreused: trueand no second upload happens (great for "I keep sharing the same screenshot"). Changing the title, full-screen, or backdrop — or the publisher's plan tier flipping the badge on/off — counts as different content and mints a fresh link instead of returning the old presentation. - Generates a 64-hex-character token via
crypto.randomBytes(32).toString('hex')(the app'sgenerateShareToken; the share relay Cloud Function mints the same 32 random bytes for a publish it has to create). The token is the URL's path segment (/s/<token>); there is no separate authentication layer — the token is the credential. 64 hex chars = 256 bits of entropy, so brute-forcing is not in scope. A 16-hex (64-bit) token is a LEGACY shape the server still accepts for shares published before the bump; every new share is 64-hex. - Inserts a
pendingrow in theshare_linkstable BEFORE the upload starts. If Omniscio crashes mid-upload, the row is reconcilable on next launch (and the orphan is cleaned up automatically when its corresponding blob never materialises). - Uploads the rendered shell HTML to Firebase Cloud Storage at
shares/<token>.htmlin the share bucket. The shell embeds all content as base64 / inlined CSS / inlined hljs theme, plus the Omniscio app icon as an inlineddata:favicon (so the browser tab shows Omniscio branding). For HTML / React shares, the author's runnable code is uploaded as a sibling blob atshares/<token>.run.html(served from/s/<token>/rununder the sandbox CSP — see "Security model"); the shell frames it via<iframe src>. Static kinds (markdown / text / code / image / pdf / SVG) have no run doc — the shell is genuinely self-contained on its own. - Flips the row to
publishedwith the final URL (https://shares.omniscio.com/s/<token>). Telemetry fires (share_artifact_publish/fired) withartifactType,reused,sourceType∈'file-peek','paste-modal','chat-link','cli','republish', andautoStaged: boolean(true when the renderer copied an out-of-scope source path into<userData>/published-pastes/before validating) so the in-app Stats view can split traffic by origin and stage path. - Copies the URL to your clipboard and raises a single success toast — "Published — link copied" or "Already published — reusing link" depending on whether the dedup branch fired.
Where to find it
Where to publish from
You can publish:
- Any file inside an active session's working directory. The path allow-list is built from every non-archived / non-ended / non-paused session's
resolveSessionWorkDir(session, project). A caller that identifies itself (a session publishing over the CLI with its own id) gets only ITS OWN working directory, never a sibling session's (RT-F007). Files inside<project-folder>/.claude/amc-attachments/<sessionId>/(where chat attachments land) qualify, as does anything else the agent has written into the project tree. - Any file inside Omniscio's user-data dir.
<userData>/published-pastes/(where the paste modal stages its uploads),<userData>/attachments/(the fallback path for chat attachments when the project folder is read-only),<userData>/bug-reports/, and so on. The user-data dir is added to the allow-list because Omniscio writes legitimate share material there. - Any file you can right-click in chat — even if it's outside both lists above. When a renderer entry point (file-peek toolbar, chat-link right-click menu, paste modal, or a file dropped on the Shares panel) hands the service a
sourcePaththat fails the allow-list check, the publish is refused withneeds-user-gestureand the renderer pops a native OS confirmation — "Publish this file publicly?" — before anything leaves your machine. Approving it mints a one-shot, path-boundshare-publishcapability token; the renderer retries the publish with that token, the service auto-stages the file by copying its raw bytes into<userData>/published-pastes/<uuid>/<original name>(the same dir the paste modal uses, one level down) and re-validating, and the file publishes. Cancel the dialog and nothing is copied, uploaded or published: a silent renderer (a compromised plugin panel, say) holds no token and is refused outright, which is the point — the confirmation is a main-mediated OS dialog the renderer cannot script or auto-dismiss. (An in-allow-list file never reaches this: it publishes on the first call with no dialog, so the common path is unchanged.) Telemetry recordsautoStaged: trueon the resultingshare_artifact_publishevent so the Stats view can split staged-vs-direct traffic. Symlinks still resolve throughfs.realpathbefore the original check, so symlink-escape is not a back door. - A credential-shaped file is the one exception, and it is absolute. A file whose NAME looks like key material — a
.envand its variants,.npmrc/.netrc/.pgpassand the other credential dotfiles, an SSH private key, atoken/secret/credentialword as a delimited part of the name (soapi-token.txtandsecrets.json, but neverdesign-tokens.cssortokenizer-notes.md), a key-material suffix, a.mcp.json, a GitHub CLIgh/hosts.yml, a cloud service-account oradminsdkJSON key, or ANY file inside a.git,.docker,.kubeor.claudefolder — is refused outright on every road, including this one. The refusal carries its own code,sensitive-filename, so it never reads as an allow-list miss: the folder was never the problem, the name is. It is never auto-staged: staging renames the file, and the deny-gate can only recognise a file by its name, so a rescued secret would re-validate clean and publish. Expect a plain refusal, with no confirm prompt to click through. - A credential-shaped file is the one exception, and it is absolute. A file whose NAME looks like key material — a
.envand its variants,.npmrc/.netrc/.pgpassand the other credential dotfiles, an SSH private key, atoken/secret/credentialword as a delimited part of the name (soapi-token.txtandsecrets.json, but neverdesign-tokens.cssortokenizer-notes.md), a key-material suffix — is refused outright on every road, including this one. Inside an allowed folder the refusal carries its own code,sensitive-filename, so it never reads as an allow-list miss: the folder was never the problem, the name is, and there is no confirm prompt to click through. Outside the allow-list the refusal is the plainoutside-allowlist, like any other outside file, so it cannot be used to learn which files exist. On either road it is never auto-staged: the stage step checks the file's real name (a symlink is followed, so a harmless-looking link to a.envis refused too) before it copies a byte, and a refused stage leaves nothing behind. - The CLI route stays strict.
POST /share/publishcalls withsourceType: 'cli'are rejected withoutside-allowlistwhen the path is outside the allow-list — no auto-stage. The trust model splits here: a user gesture (right-click, toolbar button) is treated as consent to copy file bytes; a scripted caller has to explicitly stage its own files into an allow-listed dir first to prevent automated exfil scenarios.
Path-traversal sequences (..\..\..\Users\me\.ssh\id_rsa) are resolved before the check — the allow-list compares real paths, not as-typed paths.
How it behaves
Supported types
The publish pipeline detects the artifact kind by extension first, then sniffs magic bytes to defend against extension/content mismatch. Recognised kinds:
- HTML —
.html,.htm. The author's markup is served as a separate same-origin document at/s/<token>/run(stored asshares/<token>.run.html) and embedded by the share shell via<iframe src="/s/<token>/run" sandbox="allow-scripts …">—src, notsrcdoc. The run doc carries asandboxCSP (withoutallow-same-origin), so its<script>blocks execute live but in an opaque origin: the running JS cannot read cookies / localStorage / any sibling share onshares.omniscio.com, cannot persist web storage at all, and cannot navigate the top tab. (See "Security model" for why the oldsrcdocapproach ran nothing.) - React / JSX —
.tsx,.jsx(and the "React" choice in the paste-publish modal). Same separate-origin/s/<token>/runmechanism as HTML: the run doc loads React 18 + ReactDOM + Babel-standalone fromunpkg.com, Babel transpiles JSX and TypeScript in the browser, and the bootstrap auto-mounts whichever top-level component you define (App,Component, orDemo) to#root. Fallback shows a friendly "No App / Component / Demo defined" message if none is found; runtime errors render in a styled error card instead of crashing silently. - Markdown —
.md,.markdown. Rendered by Omniscio's one shared markdown renderer (renderMarkdownin share-markdown.ts — the same pipeline behind session shares, the Word/PDF export and KMS published pages) inside the Omniscio reading page — the default look: a soft aurora backdrop of brand-coloured glows over near-black (dark) or near-white (light), a full-width top bar with the real Omniscio orb, swirling (no product name — the OMNISCIO wordmark rides in the free-tier footer instead), the document title and a round light/dark button — the bar is pinned flush to the very top — square, edge to edge, at every scroll position, so nothing ever slides through a gap above it — carrying the document's title beside the logo (an explicit title, else the opening#heading, else the share label) and, when the document has two or more sections, a Contents chip on the right that shows the reading position ("3 / 12"). Clicking the chip opens a panel attached to the underside of the bar, full width and aligned to the reading column; it closes on a click anywhere outside it, on Escape, or on picking a section, and Tab / Shift+Tab step through its headings with a soft highlight while the page scrolls each section into view (Enter or a click jumps there). The scroll and Escape run from a small hash-pinned script (OUTLINE_SCROLL_SCRIPT_BODY), so they reach live shares only once the share server is redeployed with its hash (the bar is plain and pinned at every scroll position, for every reader — there is no scroll-driven animation left to gate), one font (Geist, built into the page asdata:URLs) and one ink colour. The text is set on a modular scale of six steps, each carrying its own size AND its own weight, leading and tracking, so a level reads by its shape rather than by size alone: the share’s own title, then#as the document’s title,##as a section head (the only level that opens under a full-width hairline),###as a sub-heading,####as bold body text, and#####/######as small upper-case eyebrows. A document that opens with prose opens with a lede — larger prose — whether it begins straight at a paragraph or at its own#title followed by an intro paragraph.*italic*renders as italic. A document with two or more sections also gets that Contents chip and its "On this page" panel — the SAME control at every width, with no floating button on a phone and no always-visible rail on a wide screen. The panel opens from page markup and CSS alone; one small script adds the rest — T opens or closes it, J / K — or Tab / Shift+Tab while no link or button has focus — jump to the next or previous section (Tab focuses the heading itself and falls through to the browser past either end), Esc closes it, the arrow keys, Home and End move through the list, choosing a section closes it, the section being read is highlighted, and the chip shows the reading position. A click anywhere outside the panel closes it too. The keys never fire while the reader is typing or holding Ctrl, Alt or Cmd, and the key hints at the foot of the menu appear only once the script is running, so a page never advertises keys that do nothing. That script is allowed by the share security policy by its fingerprint, like the theme toggle, so it starts working on public pages once the share server is next published; the document’s opening#heading counts as the page title rather than a section, and a document with fewer than two sections gets no outline and no button. The classic Book report style (one warm paper column, Source Serif 4) is still available: passmarkdownStyle: "book"when you publish. Tables wear a frame that hugs the table’s own width instead of stretching across the column — a tinted header row and rule-separated rows inside it — and a long web address or code snippet inside a cell still wraps onto the next line, so a table fits the reading column instead of scrolling sideways (only a table with too many columns to ever fit scrolls, inside its own box); code blocks sit on a soft tint with GitHub syntax colours that follow light/dark mode, and long code lines scroll sideways rather than wrapping. A quote that is not a callout sits on a tinted panel, wherever the renderer produces one — at the top level, inside a list item, inside a footnote or a<details>block, or inside a callout — and a quote nested inside another quote keeps that panel at a smaller size; a quote standing at the top level is instead the display device — centred and set larger than the body, marked by a short accent rule above it — and a callout nested inside a quote (> > [!NOTE]) keeps its own hue panel rather than being repainted as a plain quote. A callout is a tinted panel whose title is an upper-case label with a coloured dot, one hue per type, so the type is legible at a glance. Neither a quote nor a callout carries a coloured stripe down its side. Printing drops the top bar and the outline and sets the page black on white. There is no synthetic filename masthead unless you explicitly provide atitle. The full GFM feature set renders: headings h1–h6, nested and ordered lists, task-list checkboxes (inert), tables with column alignment, blockquotes (multi-line, nested, with lists inside), fenced code with syntax highlighting when a language is named (an unlabeled fence stays plain), inline code, links, images, bold / italic / strikethrough, hard line breaks, horizontal rules, footnotes ([^1]refs become superscripts; definitions collect in a footnotes section at the end) and GitHub callouts — a quote opening with[!NOTE],[!TIP],[!IMPORTANT],[!WARNING]or[!CAUTION]becomes a titled callout box, the same rule the app's chat uses. A few inline HTML tags render too:<kbd>key caps,<sub>,<mark>,<u>, a<details>/<summary>click-to-expand section, and<div align="center">/rightblocks — always with every other attribute stripped. Math and diagrams are drawn when you publish, so the page still runs no script for them:$…$renders as an inline formula and a$$ … $$block as a display formula (KaTeX — the same library the app's chat uses), and a```mermaidblock becomes the diagram, drawn by the app window in both light and dark and switched to match the page's theme. Prices are never read as math — a$followed by a space, or a closing$followed by a digit, does not count, so "$540–$1,800" and "$5 and $10" stay text, as do\$and anything in code. A diagram that has an error, or that the app window cannot draw in time, keeps showing its source as code, and publishing never fails because of one. Math fonts are added only to pages that contain math. Shared conversations, vault pages and Word/PDF exports keep showing$…$and mermaid source as plain text. Raw HTML inside markdown is sanitized, never executed: dangerous tags and attributes are removed,<!-- HTML comments -->are dropped entirely (they never print as text), and only safe inline markup survives — markdown stays static even though sibling HTML artifacts run scripts. Do not convert markdown to HTML yourself before publishing — publish the.mdpath (orcontentType: "markdown") and let this renderer do it; a hand-rolled converter is how blockquotes and working-note comments end up printed on the page as text (2026-09-10). Open the document with a short bulleted summary right under its title — every agent's standing publish instruction asks for it, so a reader gets the gist before the detail. A share published before that date keeps its old render until it is republished. The same holds for the Book look (2026-10-05): an older markdown share keeps its old layout until it is republished, and republishing the same file now mints the new page. The Omniscio look and its outline (2026-10-10) behave the same way — an existing link keeps the look it was published with, and because the reading skin is now part of a markdown share’s identity, re-publishing a file you shared before that date returns a new link in the new look rather than reusing the old one. The reading page itself was redesigned again on 2026-10-12, and that last part is NOT true of it — what a markdown share’s identity carries is the reading skin’s name (omniscio), not its stylesheet, so re-publishing the very same file with the same title and label resolves to the same share and hands back the same link wearing the OLD design. To move an existing markdown link onto the new look, republish it in place (the same public URL with new content) or change something the identity does distinguish, such as the title or the label, which mints a fresh link. Nothing already published changes on its own. The real logo and the keyboard-friendly Contents menu (2026-10-15) follow the same rule as the 2026-10-12 redesign. Table wrapping, callouts and the extra inline tags (2026-10-06), and math and diagrams (2026-10-06), likewise reach an older share only when it is republished. - SVG —
.svg. Shown as a picture: the file is embedded unchanged as a base64data:image/svg+xml<img>, never inlined as markup (magic-byte check looks for<svgwithin the first 1 KB to allow XML prologues). A browser draws an SVG loaded as an image without running its scripts, following its links or loading anything outside it, so the file adds no elements to the page (see Security in part 2). Because the drawing is a picture, its text cannot be selected, so an SVG share takes general comments only. - Images —
.png,.jpg,.jpeg,.gif,.webp. Magic-byte verified (PNG header, JPEG SOI marker, GIF87a/89a, RIFF/WEBP, GIF). Embedded as a single inline base64<img>so the share page is genuinely self-contained — no hot-link to the original. - PDF —
.pdf. Magic-byte verified (%PDF-). Embedded as a base64<embed>so the browser's native PDF viewer renders it inline; the served share page's CSP grantsobject-src data:to permit the plugin data (without it the document area renders blank). - Plain text —
.txt,.json,.xml,.csv,.tsv,.log. Wrapped in a<pre>block with no syntax highlighting. - Code —
.ts,.js,.py,.css,.scss,.go,.rs,.java,.rb,.sh,.ps1,.yml,.yaml,.toml. Highlighted viahighlight.jslanguage auto-detection. Note:.tsxand.jsxroute to React (above), not Code — they execute by default. If you want syntax-highlighted-only output for a.tsxfile, paste it through the modal withTextselected.
Anything outside that list — Office docs (.docx, .xlsx, .pptx), archives (.zip, .tar.gz), binaries (.exe, .dll, .dmg), source bundles Omniscio doesn't have a renderer for — is rejected at submit time with unsupported-type. If the extension says one thing but the magic bytes say another (e.g. an .exe renamed to .png), it's rejected with magic-byte-mismatch. Empty files are rejected with empty-file. A text file that is not valid UTF-8 is rejected with invalid-encoding (a file saved as UTF-16 with a byte-order mark is converted and publishes normally) — see Troubleshooting in part 2.
Presentation controls (title, full-screen, backdrop)
Every publish — in-app or CLI — can set how the share page presents, on top of the content itself:
Title — sets the browser-tab title, the link-preview (OpenGraph) title, and any visible share masthead. On the generic framed shell it is the page
<h1>; on markdown it opts into a document masthead; without it, markdown keeps the filename in metadata only and does not inject a visible filename banner. A full-bleed html / react share (the default) has no chrome at all, so theretitlesets only the tab + unfurl title — never a visible on-page heading (the page is exactly what the author rendered). The existing label becomes the smaller subtitle on the framed shell, and rides in the top bar on markdown (never repeating the filename or the title). OG-card-title precedence is title → label → filename.Full-screen (full-bleed) — drops the fixed Omniscio frame (the centred reading column and the heading) so the page fills the whole viewport. HTML and React shares are full-screen BY DEFAULT — the author controls the whole page, so a publish that doesn't say otherwise (the AI's
POST /share/publish path=… label=…, the file-peek Share button, the chat-link right-click) shows the content edge-to-edge with no filename heading and no frame. To get the framed reading view for an HTML/React share instead, passfullBleed: false(or uncheck Full-screen in the paste modal). The framed view viewport-locks the page and the artifact fills the space below the heading as a single scroll region — never a fixed-height inner pane that double-scrolls against the page. Honored only for HTML / React / image shares; every other kind ignores it and stays framed. Markdown's default framed mode is now a deliberate Omniscio document preset rather than the old generic filename wrapper, and image stays framed-by-default (a shared screenshot keeps its caption unless you passfullBleed: true). The HTML/React content still runs inside the same opaque-origin sandboxed iframe pointed at/s/<token>/run— full-screen never relaxes the security model. On a phone it always renders WHOLE + single-scroll, never cut off: a responsive page (one that declares a@mediaquery or awidth=device-widthviewport) renders full-width in its phone layout — Omniscio hosts it at the device's real width so the author's mobile breakpoints actually fire (without that, mobile browsers lay a framed sub-page out at a ~980px desktop width and shrink it — the "two cramped columns on a phone" bug, fixed 2026-08-10) — and because Omniscio gives it exactly one screen and lets the page scroll itself, a header the author pinned to the top of the page stays pinned while the reader scrolls (before 2026-09-06 a page taller than the screen was handed a frame as tall as its whole content, which never scrolls, so everyposition: sticky/position: fixedelement silently slid away — and whether it happened came down to load timing, so the same page pinned on one device and not another); a fluid / normal-flow page (width:100%, no breakpoints) is rendered directly — exactly the way a browser renders the file, one scrollbar, no shrinking and no measure/scale machinery, so it can never double-scroll; and a page the author built at a fixed desktop width (e.g. ~1140px, no responsive CSS) is automatically scaled down to fit the screen and centred (the "fit shell" — Omniscio measures the content's natural width and shrinks the whole thing; pinch-to-zoom restores detail), so nothing strands off the side. Either way, a page that locks itself to the viewport (height:100vh/overflow:hidden— the classic "app shell" that gets cut off) is gently normalized so it flows and scrolls as one document instead of clipping. The author writes no responsive CSS, and needs no share-specific tricks, for any of this to work. Opened in a background tab, it stays light until you look at it, then reliably appears — to keep the browser from choking when many heavy shares are opened at once, the fit shell holds the render until the tab is actually viewed, and it reveals through multiple independent signals so it can never get stuck on a blank/black screen waiting for one that never fires.Backdrop colour — only meaningful with full-screen. Pass a colour (hex or
rgb()— strictly validated; anything else is ignored) or leave it blank for an automatic backdrop: an image gets a soft blurred copy of itself behind it (the blurred-art treatment), and an HTML / React page gets a backdrop matched to the artifact's own theme — a dark page gets a dark backdrop, a light page a white one (an artifact that declares no theme falls back to an OS-aware neutral) — so a dark share never flashes white before it paints, on any device and independent of the viewer's OS light/dark setting. That same artifact-matched theme also drives the page's native scrollbars (and form controls), so a dark share no longer shows bright white scrollbars inside the app or on a light-mode machine (the theme is read from the artifact's owncolor-scheme/ background — see the share-artifacts contract's scrollbar-theming invariant).A shared page always scrolls to its bottom. Pages can switch off their own scrolling in many ways — Omniscio's own stylesheet does, as do pages that lock scrolling with top-priority rules, lock it later from a script, or put everything inside a full-screen box. Every shared HTML / React page now carries a small self-check: whenever there is more page than screen and something has locked it, it turns scrolling back on (vertical only, pinch-zoom kept), and it leaves pages that fit one screen, or that already have their own scroll area, alone. Shares published earlier get the same check when they are opened — no re-publish needed. Known limits: a page that blocks all scripts, a page that pins itself in place behind a pop-up, a page whose own code cancels the wheel or swipe, and a slide deck that deliberately hides later slides. Every night (operator computer, 5:30 AM) a set of "Scroll check: …" test shares on the owner's account is opened on the live site at desktop and phone size and scrolled to the bottom; a page that gets stuck raises one inbox alert with its link, and a night the check could not run is reported as such, never as a pass. The operator can also run that check by hand, and read back its recent nights.
Links inside a shared HTML / React page open in a new browser tab. The artifact runs in a locked-down sandbox whose security policy only permits a short list of destinations, so letting a link navigate that frame does not take the reader anywhere — it replaces the page with the browser's error screen, and there is no way back. Omniscio now routes the click out to a real tab instead, and the shared page stays on screen behind it. In-page jump links (a table of contents) still scroll where they always did,
mailto:links still open a mail app, and ctrl- or middle-clicking still behaves normally. This travels in the published page itself, so a share published before 2026-09-11 keeps the old behaviour until you re-publish it.
A change to any of these counts as a new share for dedup purposes — see "What gets uploaded" below. In the app, the paste modal exposes the Title field, the Full-screen toggle (shown for HTML / React), and the backdrop box; from a script or an Omniscio-spawned agent, pass title / fullBleed / background on POST /share/publish (share-cli.md). Markdown pages have one more presentation knob — markdownStyle ("omniscio", the default, or "book") — and any name other than those two is refused rather than ignored.
"Made with Omniscio" badge (free tier)
Shared pages published by non-paid (free-tier) users carry a small "Made with Omniscio" badge — a gradient app mark + the wordmark linking to the product site. It appears on every share shell: the framed reading view, the markdown document preset, and the chromeless full-bleed HTML / React / image pages (the surface that previously had no branding at all). On every shell but markdown it is a fixed pill in the bottom-right corner; on a markdown page it is a real footer at the end of the page instead — the orb, “Made with”, and Omniscio as a link to the product site — so it never competes with the page’s own header and Contents control. Pro, Team, Enterprise and Developer get unbranded pages — removing the badge is the paid perk. This replaces the old always-on "Shared via Omniscio" footer.
Mechanics:
- Decided at publish time by one predicate,
currentUserCanPublishUnbrandedShare()— the per-tier rule (SHARE_UNBRANDED_BY_TIERin the paid-offering manifest: Pro / Team / Enterprise / Developer) OR an admin-designated per-accountunbranded-sharesadd-on. Fail-closed: free, or an unknown / not-yet-resolved tier, shows the badge; only a reliably-known entitlement hides it. It is baked into the uploaded HTML, so an existing share keeps whatever branding it was published with — upgrading affects only new publishes. The badge state is folded into the dedup key, so re-publishing the same bytes after a tier change mints a fresh, correctly-branded link instead of returning a stale one. - Official pill branding — The fixed badge uses the official animated orb and gradient Omniscio wordmark. Visitors who request reduced motion get the static orb. Both assets are embedded in the page, so displaying the logo needs no outside download or script.
- Pure HTML + CSS, no script — the outer shell's
script-src 'none'CSP is untouched. The pill is a self-contained translucent-dark chip (its own blurred backdrop + border) so it stays legible on any artifact background or light/dark theme. On the framed reading view and the full-bleed HTML / React / image pages it sits onposition: fixed, so it renders identically on all three; the markdown page places it in the page footer instead (see above), and its markup and CSS are emitted only when a badge exists — a paid markdown page carries no trace of the badge at all. - Soft-trust model — being baked client-side, it follows the same posture as every "Made with X" badge (a determined free user could strip it from their own local copy). Real paid enforcement (share quotas, pooled-AI allowances) stays server-side; the badge is growth/branding, not a security boundary.
- No user-facing toggle — but an individual account CAN be approved. There is deliberately no switch in Settings: a self-serve one would defeat the freemium model. An admin can instead grant the
unbranded-sharesadd-on to one account, which unlocks unbranded pages without moving that user's plan — the intended path for a customer who needs clean pages on an internal document. It is admin-designated only (seeded from the cloud profile at sign-in, never settable locally), and it is additive: granting it never disturbs another add-on the account already holds. - A share that is unexpectedly badged is worth checking against the account’s sign-in. The badge follows the effective tier, and a cached sign-in that can no longer verify itself ages that tier out to free — so a genuinely paid user whose credential broke starts getting badged pages with nothing else to explain it. Omniscio now raises an inbox notice when it reaches that state; see data-folder-recovery.
Writing a React artifact
The React runtime expects exactly one top-level component, named App (preferred), Component, or Demo — the bootstrap auto-mounts whichever it finds first. React 18's createRoot API is used internally; hooks (useState, useEffect, etc.) work out of the box because React 18 is loaded globally before your code runs.
Minimal example:
function App() {
const [count, setCount] = React.useState(0)
return (
<div style={{ padding: 16 }}>
<h1>Counter: {count}</h1>
<button onClick={() => setCount(count + 1)}>Increment</button>
</div>
)
}
TypeScript also works — Babel's typescript preset strips type annotations:
type Props = { name: string }
function App({ name }: Props = { name: 'World' }) {
return <h1>Hello, {name}!</h1>
}
Notes:
ReactandReactDOMare globals (loaded from unpkg before your code). UseReact.useState,React.useEffect, etc., or destructure:const { useState } = React.- You can import third-party libraries via
<script>tags before your component definition if you load them through the paste modal's HTML option and embed React manually — but the React kind itself doesn't supportimportstatements (Babel-standalone runs in non-module mode for in-browser transpilation). - No SSR, no server APIs, no build tooling — pure client-side. If you need a build step, publish the built output as an HTML artifact instead.
- Render failures (syntax errors, runtime crashes) show in a styled red error card so the viewer sees what went wrong instead of a blank page.
- Blocked-frame hint (full-bleed HTML/React). A full-bleed HTML/React share renders the artifact inside a nested sandboxed
<iframe srcdoc>(the scale-to-fit "fit-host" served at/s/<token>/run). A viewer's content-blocker — an ad, script, or privacy extension — can kill that innerabout:srcdocframe, leaving the browser's dead "about:srcdoc … temporarily down" page with no explanation. The fit-host detects this: the inner frame's size report doubles as a liveness signal, so if none arrives within ~5s (the frame's scripts never ran) it reveals a dismissible, theme-aware hint banner ("a browser extension may be blocking this — open in a private/incognito window or disable your blocker for this page"), and hides it again if a late report arrives (a merely-slow share flashes at worst). The share itself is not broken — it serves 200 and renders in a clean browser; the hint just explains a viewer-side block. Full-bleed only (that's the path with the nested frame). See share-artifacts-contractfull-bleed-fits-a-phone.
Commenting
Shares can optionally allow public comments. The commentsEnabled field on a share toggles a comment widget in the published page — the comment app bundle is injected into the share shell when enabled. During publish, the paste modal and CLI flow expose a Team Chat channel picker so the share can be linked to a Team Chat channel; new comments on the share are then cross-posted as thread replies to that channel via the onCommentCreate Cloud Function. Full contract: share-comments-contract.md.
Privacy + audit-log details: share-view-events.md.
Republish as new
Useful when you want a fresh URL for the same content (different recipient, separate tracking, etc.). The Republish as new action in the Shares view row menu mints a brand-new token, points it at the same uploaded blob (re-uploaded under the new token, dedup deliberately bypassed), and revokes the old token. Available only while the original is still active and has a backing sourcePath (so re-uploading is possible). Full UX + IPC contract: shares-view.md § Per-row actions and the SHARE_REPUBLISH channel.
The whole share lifecycle is also a script surface. Beside the in-app flow and the session /
message / selection sharing on artifact-sharing.md, the local control server
exposes publish, list, revoke and delete (POST /share/publish, GET /share/list,
POST /share/:token/revoke, DELETE /share/:token) — the caller's reference is
share-cli.md — plus the manage routes over one already-published share
(GET /share/:token/status, PATCH /share/:token for label / expiry / view-cap / notify /
comments, POST /share/:token/protection for the password gate, POST /share/:token/republish,
GET /share/:token/comments), delivery of a share link to a recipient by Gmail / SMS / Slack
(POST /share/:token/send), and the Google Docs round-trip (POST /gdoc/import,
POST /gdoc/publish).
Delivery limits and reclamation
Every served byte of a share is bounded. A page, its run document and its sandboxed inner body each
charge the same per-share daily delivery counter a file share uses (5 GB per UTC day per token),
and a GCS-hosted video is charged before its link is issued — the whole object on the default
signed-redirect path, because that link grants the whole file, and only the parsed range on the
stream-through path — so /run is never a free bypass. A share
that is fully unprotected is served public, s-maxage=60 so the CDN absorbs repeat views; a
password-, view-cap- or workspace-gated share stays no-store. A page object is capped at 10 MiB
at upload.
Publishing from the app is bounded too. Each in-app action that creates a public link (publishing an artifact, sharing a session, sharing a digest, republishing) allows 10 calls a minute, counted per action, because each is reachable over the phone bridge and spends cloud storage. A looping screen or a leaked paired token therefore cannot mass-publish, while a person publishing by hand never reaches the cap; a refused call shows "Too many requests" and publishes nothing.
Storage is bounded the same way. A scheduled server-side sweep deletes the video of any share whose expiry has passed, whether or not a desktop app is open (it removes the video only — the page, PNG and file objects and the mirror doc stay, and an unexpired share is never touched). A fleet-wide total video-storage ceiling stops a free-tier publish that would cross it, and a daily job measures the fleet's stored video bytes and raises a log alert on the way to the R2 free tier and to that ceiling. The contract and the numbers live in r2-video-serving-contract.md I17–I19.
Related
Share Artifacts (publish local files and pasted content as links) (part 2) — the continuation of this page.
Share Artifacts (publish local files and pasted content as links) (part 3) — the continuation of this page.
shares-view.md — the top-level sidebar view that lists / edits / revokes / deletes every share you've created (replaces the old Settings → Sharing list)
share-cli.md — same publish pipeline, called from a script or external AI via the CLI control server
share-view-events.md — privacy model + audit-log shape for the view-tracking pipeline
artifact-sharing.md — the sibling feature for sessions / messages / selections (different inputs, same
share_linkstable and URL space)cli-control.md — the CLI control server that hosts
POST /share/publishand the three lifecycle endpoints
Last verified 2026-10-15