@sableui/react 0.5.0 → 0.6.1

package/scripts/design-presets.mjs

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs"
 import { resolve } from "node:path"
 import { fileURLToPath } from "node:url"
-import { parsePreset, presetCss } from "../dist/presets/index.js"
+import { LABEL_CONTRAST_RULE, parsePreset, presetCss, presetLabelContrast } from "../dist/presets/index.js"
 import { parseFlags } from "./design-preferences.mjs"
 
 const packageRoot = fileURLToPath(new URL("../", import.meta.url))
@@ -39,10 +39,33 @@ try {
 		const file = flags.get(action)
 		if (!file || file.startsWith("--")) throw new Error(`${action} requires a preset JSON path.`)
 		const preset = parsePreset(JSON.parse(readFileSync(resolve(file), "utf8")))
-		if (action === "--check") emit("preset.check", { valid: true, id: preset.id, revision: preset.revision, authoredWith: preset.sableVersion }, `Valid preset ${preset.id}, revision ${preset.revision}. Review rendered contrast and brief fit separately.`)
-		else { const css = presetCss(preset); emit("preset.css", { id: preset.id, revision: preset.revision, css }, css) }
+		if (action === "--check") {
+			// Labels on brand and status fills: Sable's opinion, enforced unless the preset
+			// records that it declines it (`exceptions`), which is then reported.
+			const labels = presetLabelContrast(preset)
+			const pair = f => `${f.mode} ${f.fill}-foreground on ${f.fill}: ${f.ratio.toFixed(2)}:1, APCA Lc ${Math.abs(f.lc).toFixed(0)}`
+			if (labels.open.length) {
+				const exceptions = labels.open.map(f => JSON.stringify({ rule: LABEL_CONTRAST_RULE, mode: f.mode, token: f.fill, reason: "<why>" }))
+				const err = new Error(
+					"Labels on filled roles must clear 4.5:1 and APCA Lc 60. These fail the ratio or read muddy:\n" +
+					labels.open.map(f => `  ${pair(f)} → try ${f.fill}: ${f.suggestion.fill}; ${f.fill}-foreground: ${f.suggestion.ink}`).join("\n") +
+					`\nTo keep a pair as designed, record it in the preset: "exceptions": [${exceptions.join(", ")}]`,
+				)
+				err.code = "ERR_PRESET_CONTRAST"
+				err.data = { findings: labels.open }
+				err.suggestions = ["Apply the suggested fill/ink pairs", "Or add an exceptions entry with a reason", "sable docs creating-a-preset"]
+				throw err
+			}
+			const accepted = labels.accepted.map(f => `\n  accepted: ${pair(f)} — ${f.reason}`).join("")
+			const unmeasured = labels.unmeasured.length ? `, ${labels.unmeasured.length} unmeasured (${labels.unmeasured.join(", ")})` : ""
+			emit(
+				"preset.check",
+				{ valid: true, id: preset.id, revision: preset.revision, authoredWith: preset.sableVersion, labelContrast: { measured: labels.measured, accepted: labels.accepted, unmeasured: labels.unmeasured } },
+				`Valid preset ${preset.id}, revision ${preset.revision}. Labels on filled roles: ${labels.measured} pairs measured${unmeasured}.${accepted}\nReview rendered contrast and brief fit separately.`,
+			)
+		} else { const css = presetCss(preset); emit("preset.css", { id: preset.id, revision: preset.revision, css }, css) }
 	}
 } catch (error) {
-	process.stderr.write(JSON.stringify({ type: "error", code: "ERR_PRESET_INVALID", message: error.message, suggestions: ["sable docs using-presets", "sable preset --template"] }) + "\n")
+	process.stderr.write(JSON.stringify({ type: "error", code: error.code ?? "ERR_PRESET_INVALID", message: error.message, ...(error.data ? { data: error.data } : {}), suggestions: error.suggestions ?? ["sable docs using-presets", "sable preset --template"] }) + "\n")
 	process.exitCode = 1
 }

package/scripts/grade.mjs

@@ -34,6 +34,7 @@ import { createHash } from "node:crypto"
 import { dirname, extname, join, relative, resolve } from "node:path"
 import { fileURLToPath } from "node:url"
 import { ignoreGlob, lintText, makeRules } from "./lint-rules.mjs"
+import { labelContrastScanner, statusTextDrift } from "./label-contrast.mjs"
 import { skeletonize } from "./skeleton.mjs"
 import { assessReview, reviewTemplate } from "./review-evidence.mjs"
 
@@ -108,7 +109,7 @@ const motionTokens = new Set(
 		REGISTRY.tokens?.motion?.scale,
 	].filter(Boolean),
 )
-const RULES = makeRules({ semanticTokens, motionTokens }).filter((r) => r.scope !== "package")
+const RULES = makeRules({ semanticTokens, motionTokens, labelContrast: await labelContrastScanner(PKG_ROOT, REGISTRY.themes?.default), statusText: (css) => statusTextDrift(css, REGISTRY.themes?.default) }).filter((r) => r.scope !== "package")
 const PROP_SURFACE = REGISTRY.propSurface?.items ?? {}
 const ICONS = new Set(REGISTRY.iconContract?.names ?? [])
 /**

package/scripts/label-contrast.mjs

@@ -0,0 +1,174 @@
+/**
+ * The `label-contrast` lint rule's reader: which brand-fill tokens a stylesheet
+ * overrides, in which mode and theme, measured on top of the installed theme.
+ *
+ * The rule itself lives in lint-rules.mjs with the others; it stays dependency
+ * free by taking this scanner as an argument. The measuring is the package's own
+ * (`checkLabelledFills` from the built `presets` entry), so the linter, `sable
+ * preset --check`, Sable's theme tests and Customize cannot disagree about what
+ * reads.
+ *
+ * An app overriding `--primary` usually leaves `--primary-foreground` to the
+ * theme, and that is exactly the pair that goes wrong — so a pair is completed
+ * from the theme the selector names (`[data-sable-theme="ember"]`), or the
+ * default theme. Only pairs the stylesheet itself declares a half of are
+ * reported; the theme's own pairs are Sable's to keep.
+ */
+
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { pathToFileURL } from "node:url"
+
+const DARK = /\.dark\b|\[data-(?:theme|mode|color-scheme)=["']?dark|prefers-color-scheme:\s*dark/
+const LIGHT = /\.light\b|\[data-(?:theme|mode|color-scheme)=["']?light|prefers-color-scheme:\s*light/
+const THEME = /data-sable-theme=["']?([\w-]+)/
+
+const stripComments = (css) => css.replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "))
+
+/** Every `--name: value` inside a block, with its offset and enclosing preludes. */
+export function customProperties(css) {
+	const out = []
+	const stack = []
+	let start = 0
+	const take = (end) => {
+		const text = css.slice(start, end)
+		const m = text.match(/^\s*--([\w-]+)\s*:\s*([\s\S]*?)\s*$/)
+		if (m && stack.length) out.push({ name: m[1], value: m[2], index: start + text.indexOf("--"), context: stack.join(" ") })
+	}
+	for (let i = 0; i < css.length; i++) {
+		const ch = css[i]
+		if (ch === "{") {
+			stack.push(css.slice(start, i).trim())
+			start = i + 1
+		} else if (ch === "}") {
+			take(i)
+			stack.pop()
+			start = i + 1
+		} else if (ch === ";") {
+			take(i)
+			start = i + 1
+		}
+	}
+	return out
+}
+
+const modeOf = (decl) => (DARK.test(decl.context) ? "dark" : LIGHT.test(decl.context) ? "light" : "both")
+const applies = (decl, mode) => {
+	const m = modeOf(decl)
+	return m === "both" || m === mode
+}
+
+/**
+ * Light and dark token maps. A declaration outside any dark scope reaches dark
+ * mode too: an app's stylesheet loads after Sable's, so `:root { --primary }`
+ * outranks the theme's equal-specificity `.dark` value.
+ */
+function modeMaps(decls, base) {
+	const light = { ...base?.light }
+	const dark = { ...base?.dark }
+	for (const d of decls) {
+		if (applies(d, "light")) light[d.name] = d.value
+		if (applies(d, "dark")) dark[d.name] = d.value
+	}
+	return { light, dark }
+}
+
+function resolveAll(map) {
+	const resolve = (value, depth) =>
+		depth > 12
+			? value
+			: value.replace(/var\(\s*--([\w-]+)\s*(?:,\s*([^()]*))?\)/g, (m, name, fallback) =>
+					map[name] != null ? resolve(map[name], depth + 1) : fallback?.trim() || m,
+				)
+	return Object.fromEntries(Object.entries(map).map(([k, v]) => [k, resolve(v, 0)]))
+}
+
+/**
+ * A scanner for one stylesheet's text, or null when the package's built entry
+ * is missing (the rule then reports nothing rather than guessing).
+ */
+export async function labelContrastScanner(pkgRoot, defaultTheme = "sable") {
+	const entry = join(pkgRoot, "dist/presets/index.js")
+	if (!existsSync(entry)) return null
+	const { checkLabelledFills, LABELLED_FILLS } = await import(pathToFileURL(entry).href)
+	const watched = new Set(LABELLED_FILLS.flatMap((f) => [f, `${f}-foreground`]))
+	const themes = new Map()
+	const theme = (id) => {
+		if (!themes.has(id)) {
+			const file = join(pkgRoot, "dist/themes", id, `${id}.css`)
+			themes.set(id, existsSync(file) ? modeMaps(customProperties(stripComments(readFileSync(file, "utf8")))) : null)
+		}
+		return themes.get(id)
+	}
+
+	return (css) => {
+		const decls = customProperties(css)
+		if (!decls.some((d) => watched.has(d.name))) return []
+		const byTheme = new Map()
+		for (const d of decls) {
+			const id = d.context.match(THEME)?.[1] ?? defaultTheme
+			if (!byTheme.has(id)) byTheme.set(id, [])
+			byTheme.get(id).push(d)
+		}
+		const out = []
+		// One declaration failing the same way in both modes is one finding.
+		const seen = new Map()
+		for (const [id, group] of byTheme) {
+			const maps = modeMaps(group, theme(id) ?? theme(defaultTheme))
+			const { findings } = checkLabelledFills({ light: resolveAll(maps.light), dark: resolveAll(maps.dark) })
+			for (const f of findings) {
+				const own = group.filter((d) => (d.name === f.fill || d.name === `${f.fill}-foreground`) && applies(d, f.mode))
+				if (!own.length) continue
+				const at = own.findLast((d) => d.name === `${f.fill}-foreground`) ?? own.at(-1)
+				const pair = `--${f.fill}-foreground on --${f.fill} is ${f.ratio.toFixed(2)}:1, APCA Lc ${Math.abs(f.lc).toFixed(0)}`
+				const fix = ` → try --${f.fill}: ${f.suggestion.fill}; --${f.fill}-foreground: ${f.suggestion.ink}`
+				const key = `${at.index}|${pair}${fix}`
+				const twin = seen.get(key)
+				if (twin) {
+					twin.match = `light and dark: ${pair}${fix}`
+					continue
+				}
+				const finding = { index: at.index, match: `${f.mode}: ${pair}${fix}` }
+				seen.set(key, finding)
+				out.push(finding)
+			}
+		}
+		return out
+	}
+}
+
+/** Status fills and the token a status colour drawn on a surface reads instead. */
+const STATUS_TEXT = { destructive: "destructive-text", success: "success-text", "tone-warning": "tone-warning-text", "tone-info": "tone-info-text" }
+
+/**
+ * The `status-text-drift` rule's reader. Since 0.6, `text-destructive`,
+ * `border-destructive`, `ring-destructive` and the rest read `--destructive-text`;
+ * only `bg-destructive` reads the fill. An app that retunes `--destructive` and
+ * stops there gets a button in its red and error text, borders and focus rings in
+ * the theme's — and nothing on screen says which is which. CSS cannot notice "the
+ * fill moved and the text did not", so the stylesheet is read for it: a status
+ * fill set, in a theme and mode, with no `-text` set beside it there.
+ *
+ * Pure: it needs the declarations only, not the built package, so it reports
+ * even where `label-contrast` cannot measure.
+ */
+export function statusTextDrift(css, defaultTheme = "sable") {
+	const decls = customProperties(stripComments(css))
+	const fills = decls.filter((d) => d.name in STATUS_TEXT)
+	if (!fills.length) return []
+	const themeOf = (d) => d.context.match(THEME)?.[1] ?? defaultTheme
+	const out = []
+	for (const d of fills) {
+		const text = STATUS_TEXT[d.name]
+		const missing = ["light", "dark"].filter(
+			(mode) => applies(d, mode) && !decls.some((t) => t.name === text && themeOf(t) === themeOf(d) && applies(t, mode)),
+		)
+		if (!missing.length) continue
+		const modes = missing.length === 2 ? "light and dark" : missing[0]
+		out.push({
+			index: d.index,
+			match: `--${d.name} is set without --${text} (${modes}): text-${d.name}, borders and rings keep the theme's colour → set --${text} too`,
+		})
+	}
+	return out
+}

package/scripts/lint-rules.mjs

@@ -118,9 +118,12 @@ function classTokens(expr) {
 /**
  * Build the rule table against a token contract.
  *
- * @param {{ semanticTokens: Set<string>, motionTokens: Set<string> }} contract
+ * @param {{ semanticTokens: Set<string>, motionTokens: Set<string>, labelContrast?: ((css: string) => { index: number, match: string }[]) | null, statusText?: ((css: string) => { index: number, match: string }[]) | null }} contract
+ *   `labelContrast` and `statusText` are the stylesheet scanners from
+ *   label-contrast.mjs. They are passed in so this table stays dependency free;
+ *   without one its rule is listed and reports nothing.
  */
-export function makeRules({ semanticTokens, motionTokens }) {
+export function makeRules({ semanticTokens, motionTokens, labelContrast = null, statusText = null }) {
 	// Easing utility names = the theme's motion-ease-* tokens + Tailwind built-ins.
 	const easeNames = new Set([
 		...[...motionTokens]
@@ -525,6 +528,40 @@ export function makeRules({ semanticTokens, motionTokens }) {
 				return out
 			},
 		},
+		{
+			id: "label-contrast",
+			/* CONSUMER-scoped. An app retunes `--primary` and keeps the theme's
+			 * label — and a red lifted for dark mode lands where dark ink passes
+			 * the ratio and reads muddy, and white fails it. Sable's themes are
+			 * held to this in themes.test.ts; an app is told and offered the fix,
+			 * and keeps its own choice with a reasoned disable. */
+			scope: "consumer",
+			since: "0.6.0",
+			file: true,
+			code: true,
+			why:
+				"A label on a filled role — brand (`--primary`, `--sidebar-primary`, `--highlight`) or status (`--destructive`, `--success`, `--tone-warning`, `--tone-info`), each with its `-foreground` — should clear 4.5:1 AND APCA Lc 60. A pair can pass the ratio and still read muddy (dark ink on a bright red-orange, Lc 42). The finding names the nearest pair that reads, with the fill's lightness moved and hue kept, keeping the ink its light-mode colour takes. A status colour drawn on a surface (`text-destructive`, borders, rings) reads `--<status>-text`, so moving the fill does not move the page's text. " +
+				"If the pair is your brand's deliberate choice, keep it on the record: `/* design-lint-disable-next-line label-contrast -- <reason> */` above the declaration.",
+			scan(text, ctx) {
+				return ctx?.isStylesheet && labelContrast ? labelContrast(text) : []
+			},
+		},
+		{
+			id: "status-text-drift",
+			/* CONSUMER-scoped. 0.6 split each status colour into a fill and a
+			 * `-text`; an app that retunes only the fill paints its buttons in its
+			 * own red and its error text, borders and rings in the theme's. Nothing
+			 * on screen says which is which, so the stylesheet is read for it. */
+			scope: "consumer",
+			since: "0.6.1",
+			file: true,
+			code: true,
+			why:
+				"A status colour has two tokens: the fill (`--destructive`, `--success`, `--tone-warning`, `--tone-info`), which `bg-*` paints, and its `-text` (`--destructive-text` …), which `text-*`, `border-*`, `ring-*`, `outline-*`, `fill-*` and `stroke-*` read. Setting the fill alone leaves the text on the theme's colour, so a retuned red button sits beside the theme's red error message. Set the `-text` in the same theme and mode: the fill itself where it already reads on your surfaces, or a step of it moved away from them (lighter in dark mode) so it clears 4.5:1 on a card.",
+			scan(text, ctx) {
+				return ctx?.isStylesheet && statusText ? statusText(text) : []
+			},
+		},
 		{
 			id: "hand-derived-surface",
 			/* CONSUMER-scoped. Mixing ink into a surface by hand is what the

package/skills/sable/SKILL.md

@@ -168,7 +168,9 @@ gaps. A visual-only review leaves code and unobserved behavior untested. For
 
 Every build includes `sable docs reviewing-a-design`, `sable doctor`,
 `sable lint <source paths> --json`, and the project's build/type checks. Repair
-findings instead of suppressing them to finish. Inspect real desktop/mobile
+findings instead of suppressing them to finish. `label-contrast` is Sable's opinion
+on a user's colour: offer its suggested pair, and when the user chose the pair
+deliberately, keep it with a reasoned disable or preset `exceptions` entry. Inspect real desktop/mobile
 layouts, operate the primary task and recovery path, check keyboard/touch and
 loading/empty/error/success states, font loading, focus, and reduced motion.
 Audit source ownership as well as lint: identify the Sable components and composed

package/targets/ios.json

@@ -3,6 +3,8 @@
   "target": "ios",
   "platformVersion": "27",
   "verifiedOn": "2026-10-10",
+  "status": "beta",
+  "statusNote": "Early preview. The web components are the mature surface; the iOS adapter and these decisions are still being iterated, so expect layout rules and chrome to change between releases. Report what looks wrong rather than patching around it.",
   "designPolicy": {
     "principle": "Sable first. Every screen is built from Sable components in the chosen preset. The adapter supplies only the iOS system chrome Sable has no equivalent for: the app frame and status bar, the navigation bar, the tab bar and sheet presentation.",
     "chrome": [
@@ -20,7 +22,12 @@
       "all content, typography and imagery"
     ],
     "rule": "Never import from konsta. Chrome comes from @sableui/react/ios; anything else is a Sable component. If Sable lacks something a screen needs, report it as a library gap rather than reaching for a native control.",
-    "styling": "One document: Tailwind, Sable styles.css, the preset, then @sableui/react/ios/styles.css. The chrome reads the preset; Sable content follows it as on the web. Align content to px-(--ios-inset)."
+    "styling": "One document: Tailwind, Sable styles.css, the preset, then @sableui/react/ios/styles.css. The chrome reads the preset; Sable content follows it as on the web. Align content to px-(--ios-inset).",
+    "layout": [
+      "A sheet owns what a card owns on a page: the surface, the edge padding and the actions. IosSheet provides a \"sheet\" PresentationProvider, and Sable lays its content out for it; do not restyle it by hand.",
+      "Actions: mark a footer that holds only buttons with <CardFooter actions>. In a sheet it becomes a full-width stack pinned to the bottom, the primary on top, every button at the cta height. A footer with a caption, a price or a list affordance stays unmarked.",
+      "Surface: pass framed={false} to a block in a sheet; a flat card there bleeds its padding so its content lines up with the sheet. Use background=\"opaque\" for a form at the medium detent; keep glass for short, read-only content."
+    ]
   },
   "implementation": {
     "package": "konsta",
@@ -446,6 +453,15 @@
       ],
       "guidance": "Use the Sable component as it is, in the preset. Adapt layout and touch targets to the phone; do not swap in a native lookalike or restyle it."
     },
+    "GradientArt": {
+      "source": "GradientArt",
+      "strategy": "preserve",
+      "importFrom": "@sableui/react",
+      "components": [
+        "GradientArt"
+      ],
+      "guidance": "Use the Sable component as it is, in the preset. Adapt layout and touch targets to the phone; do not swap in a native lookalike or restyle it."
+    },
     "InlineStatus": {
       "source": "InlineStatus",
       "strategy": "preserve",
@@ -814,7 +830,7 @@
       "components": [
         "IosSheet"
       ],
-      "guidance": "IosSheet presents and dismisses (detents, drag, Escape, focus). Everything inside it is Sable: Form, Field, Input, Button."
+      "guidance": "IosSheet presents and dismisses (detents, drag, Escape, focus). Everything inside it is Sable: Form, Field, Input, Button. The sheet owns the surface, edge padding and actions: put a block in with framed={false}, and a form at the medium detent with background=\"opaque\"."
     },
     "ShowMore": {
       "source": "ShowMore",

package/third-party/paper-shaders-LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/third-party/paper-shaders-NOTICE.txt

@@ -0,0 +1,5 @@
+Paper Shaders
+Copyright 2026 Paper
+
+Powered by Paper Shaders:
+https://shaders.paper.design