Consolidate some stuff from GS and intro, Remove 'prerelease' everywhere, etc.

Author: crandmck

docs/getting-started.mdx

@@ -106,50 +106,7 @@ The [Creator Assertions Working Group (CAWG)](https://creator-assertions.github.
 
 In addition, Adobe tools can use the [Connected Accounts service](https://connected-accounts.adobe.com/) to connect social media accounts such as Behance, Instagram, or Twitter to an identity in a manifest. This service uses OAuth, so a user must be able to log in to an Adobe account to connect it.
 
-## How to use the SDK
-
-The CAI open-source SDK consist of:
-
-- [**C2PA Tool**](c2patool/readme.md), a command-line tool for working with manifests and media. This tool is a wrapper around the Rust SDK and provides most of the same capabilities that it does.
-- [**JavaScript library**](c2pa-js) that enables web pages to verify and read manifest data using client JavaScript.
-- **[C/C++](c2pa-c/readme.md), [Python](c2pa-python/readme.md), [Node.js](c2pa-node/readme.md) libraries** that enable applications to read and validate manifest data, create and sign manifest data and embed it supported asset files.
-- [**Mobile libraries**](mobile.md) that enable mobile applications for iOS and Android to to read and generate manifest data.
-- [**The Rust library**](rust-sdk/readme.md) that generates the other language bindings and can also be used directly to read and generate manifest data.
-
-C2PA Tool and language-specific libraries are built using the Rust library to ensure consistency.
-
-The following diagram provides a high-level view of how to use the open-source CAI SDK.
-
-<img src={cai_open_source} width="800" />
-
-Applications can use the CAI SDK in several different ways:
-
-- Web pages can use the JavaScript library to display Content Credentials.
-- Applications can "shell out" to call C2PA Tool directly, though doing so is not highly scalable.
-- Applications written in C++, Python, or Node.js can use the corresponding language libraries to:
-  - Create, modify, and sign manifests.
-  - Embed manifests into media files.
-  - Parse and validate manifests.
-- Mobile apps can use the iOS and Android libraries do all the above.
-
-Alternatively, native applications can use Rust's _Foreign Function Interface_ (FFI) to call functions in the Rust library. The FFI enables interoperability between Rust and code written in other languages. For example, a Windows application can use the FFI to call Rust functions from languages such as C++ or C#. For an example, see the [c2c2pa repository](https://github.com/contentauth/c2c2pa).
-
-### Websites
-
-A website can serve web pages that use the JavaScript library to display manifest data using client JavaScript.
-A server-side web application can create, modify, and sign claims (and view them) by:
-
-- Executing a shell command to invoke C2PA Tool. For an example, see the [c2patool Node.js service example](c2pa-service-example). While this approach works, it is not highly scalable.
-- Use the [Node.js](c2pa-node), [Python](c2pa-python), or [C++/C](c2pa-c) libraries.
-- Bind to the Rust library and use it, similarly to native applications.
-
-### Embedded applications
-
-An embedded application can use the Rust FFI (foreign function interface) to call Rust functions from languages such as C or C++, similarly to a native application.
-
-Embedded applications have unique constraints tied to the devices on which they run, including small memory footprint, low-powered hardware, intermittent network access, unique operating systems, or the lack of an operating system OS (running on bare metal). For these reasons, if you want to develop a CAI-enabled embedded application, please contact the CAI team directly.
-
-## Attaching and storing the manifest
+## Attaching and storing manifest data
 
 Once you've generated a manifest, you must attach it to the asset for it to be useful.
 

docs/introduction.mdx

@@ -4,7 +4,7 @@ title: CAI open source SDK
 ---
 
 import cr_pin from '../static/img/cr-pin.png';
-import cai_open_source_red from '../static/img/cai-open-source.jpg';
+import cai_open_source from '../static/img/cai-open-source.jpg';
 
 :::tip
 You're strongly encouraged to read this introduction and [Getting started](getting-started.mdx) to give you some basic background and context, before you dive right into development. [Working with manifests](manifest/understanding.md) also has some crucial information, regardless of which language and library you use.
@@ -14,48 +14,38 @@ The Coalition for Content Provenance and Authenticity (C2PA) and Content Authent
 
 ## What's in the SDK
 
-The CAI open-source SDK (software development kit) is a set of tools and libraries that enable developers to create, verify, and display Content Credentials based on C2PA standards.
+The CAI open-source SDK consist of:
 
-<img src={cai_open_source_red} width="800" />
-
-The CAI open-source SDK consists of:
-
-- [C2PA Tool](#c2pa-tool): a command-line tool for working with C2PA manifests and media assets.
-- [The JavaScript library](#javascript-library) (also known as the JavaScript SDK): Client JavaScript library for code that runs, for example, in a web browser.
-- [Prerelease libraries](#prerelease-libraries) for Node.js, Python, and C++/C.
-- [The Rust library](#rust-library), which is the code that underlies everything else. It's the "source of truth" that all the other libraries use.
+- [**C2PA Tool**](c2patool/readme.md), a command-line tool for working with manifests and media. This tool is a wrapper around the Rust SDK and provides most of the same capabilities that it does. C2PA Tool can:
+  - Read a JSON report of manifest data.
+  - Attach a manifest store to an asset, if it doesn't already have an associated manifest store.
+  - Add a manifest to to the associated manifest store if the asset does have an associated manifest store.
+- [**JavaScript library**](c2pa-js) that enables web pages to verify and read manifest data using client JavaScript. Use it to add user interface elements to your website that display manifest data while following the [C2PA user experience recommendations](https://c2pa.org/specifications/specifications/1.0/ux/UX_Recommendations.html).
+- **[C/C++](c2pa-c/readme.md), [Python](c2pa-python/readme.md), [Node.js](c2pa-node/readme.md) libraries** that enable applications to read and validate manifest data, create and sign manifest data and embed it supported asset files.
+- [**Mobile libraries**](mobile.md) that enable mobile applications for iOS and Android to to read and generate manifest data.
+- [**The Rust library**](rust-sdk/readme.md) that generates the other language bindings and can also be used directly to read and generate manifest data. The Rust library is the fundamental system underlying everything else.
 
 To see a summary of what each tool and library can do, see [Which tool is right for you?](#which-tool-is-right-for-you).
 
-### C2PA Tool
-
-[C2PA Tool](c2patool/readme.md), is a **command-line utility for working with C2PA manifest data**. Use this tool to work with assets in a supported file format to:
-
-- Read a JSON report of manifest data.
-- Attach a manifest store to an asset, if it doesn't already have an associated manifest store.
-- Add a manifest to to the associated manifest store if the asset does have an associated manifest store.
-
-### JavaScript library
-
-The client [JavaScript library](js-sdk/js-landing.md) enables **working with manifest data in the browser**. Use this library to:
-
-- Verify and display manifest data on a website or web application.
-- Link manifest data displayed on your site to [Verify](https://verify.contentauthenticity.org/).
-- Easily add user interface elements to your website that display manifest data while following the [C2PA user experience recommendations](https://c2pa.org/specifications/specifications/1.0/ux/UX_Recommendations.html).
+The following diagram provides a high-level view of the SDK.
 
-### Other language libraries
+<img src={cai_open_source} width="800" />
 
-The [C++/C](c2pa-c/readme.md), [Python](c2pa-python/readme.md), and [Node.js](c2pa-node/readme.md) libraries enable applications written in those languages to **create, verify, and display Content Credentials**.
+## How to use the SDK
 
-### Rust library
+Applications can use the CAI SDK in several different ways:
 
-The [Rust library](rust-sdk/readme.md) enables **adding C2PA capabilities to a desktop, mobile, or embedded application**. The Rust library is the fundamental system underlying everything else. C2PA Tool uses it "under the hood" and language-specific APIs are generated from it.
+- Web pages can use the JavaScript library to display Content Credentials.
+- Applications can "shell out" to call C2PA Tool directly, though doing so is not highly scalable.
+- Applications written in C++, Python, or Node.js can use the corresponding language libraries to:
+  - Create, modify, and sign manifests.
+  - Embed manifests into media files.
+  - Parse and validate manifests.
+- Mobile apps can use the iOS and Android libraries do all the above.
 
-You can use the Rust library via the Foreign Function Interface (FFI) to:
+Native applications can also use Rust's _Foreign Function Interface_ (FFI) to call functions in the Rust library. The FFI enables interoperability between Rust and code written in other languages. For example, a Windows application can use the FFI to call Rust functions from languages such as C++ or C#. For an example, see the [c2c2pa repository](https://github.com/contentauth/c2c2pa).
 
-- Create and sign C2PA claims and manifests.
-- Embed a manifest store into certain asset file formats.
-- Parse and validate manifests found in certain asset file formats.
+An embedded application can use the Rust FFI (foreign function interface) to call Rust functions from languages such as C or C++, similarly to a native application. Embedded applications have unique constraints tied to the devices on which they run, including small memory footprint, low-powered hardware, intermittent network access, unique operating systems, or the lack of an operating system OS (running on bare metal). For these reasons, if you want to develop a CAI-enabled embedded application, please contact the CAI team directly.
 
 ## Which tool is right for you?
 
@@ -67,7 +57,7 @@ import green_check from '../static/img/green_check.png';
       <th style={{ textAlign: 'left' }}>Use To...</th>
       <th style={{ textAlign: 'left' }}>JavaScript Library </th>
       <th style={{ textAlign: 'left' }}>C2PA Tool</th>
-      <th style={{ textAlign: 'left' }}>Prerelease Libraries </th>
+      <th style={{ textAlign: 'left' }}>Python, C++, and Node.js Libraries </th>
       <th style={{ textAlign: 'left' }}>Rust Library</th>
     </tr>
   </thead>

docs/js-sdk/getting-started/overview.mdx

@@ -7,7 +7,7 @@ import Deprecation from '../deprecation-notice.md';
 
 <Deprecation name="deprecation" />
 
-The CAI JavaScript library (sometimes referred to as the "JavaScript SDK") enables client JavaScript applications to view and verify [C2PA](https://c2pa.org/) data. It performs only **read** operations on C2PA manifests, unlike the [Rust library](../../rust-sdk/), and the [prerelease libraries](../../other-langs) which can both read and write manifests.
+The CAI JavaScript library (sometimes referred to as the "JavaScript SDK") enables client JavaScript applications to view and verify [C2PA](https://c2pa.org/) data. It performs only **read** operations on C2PA manifests.
 
 ## What you should already know
 

docs/other-langs.mdx

@@ -4,12 +4,6 @@ title: Libraries for other programming languages
 pagination_prev: null
 ---
 
-:::warning Warning
-These libraries are all early prerelease versions. They may have bugs and unimplemented features, and their APIs are subject to change.
-:::
-
-The prerelease libraries enable applications written in each language to create, verify, and display content credentials:
-
 - [Node.js](c2pa-node/readme.md)
 - [Python](c2pa-python/readme.md)
 - [C++/C](c2pa-c/readme.md)

docs/signing/local-signing.md

@@ -13,7 +13,7 @@ Trust lists connect the end-entity certificate that signed a manifest back to th
 
 The simplest way to add a C2PA manifest to an asset file and sign it is by using C2PA Tool (`c2patool`). You can run C2PA Tool manually from the command line (for example, during development) and more generally from any executable program that can call out to the shell, such as a Node.js application as shown in the [c2patool Node.js service example](../c2pa-node-example).
 
-Similarly, using the Rust SDK, you can [add a manifest to an asset file](https://docs.rs/c2pa/latest/c2pa/#example-adding-a-manifest-to-a-file), referencing the certificate and private key file. The prerelease libraries for [Node.js](../c2pa-node), [Python](../c2pa-python), and [C++/C](../c2pa-c) can also add and sign a manifest.
+Similarly, using the Rust SDK, you can [add a manifest to an asset file](https://docs.rs/c2pa/latest/c2pa/#example-adding-a-manifest-to-a-file), referencing the certificate and private key file. The [Node.js](../c2pa-node), [Python](../c2pa-python), and [C++/C](../c2pa-c) libraries can also add and sign a manifest.
 
 :::warning Warning
 Accessing a private key and certificate directly from the file system is fine during development, but doing so in production is not secure. Instead use a Key Management Service (KMS) or a hardware security module (HSM) to access the certificate and key; For more information, see [Using a certificate in production](prod-cert.mdx). 

docs/signing/test-certs.md

@@ -7,7 +7,7 @@ The CAI SDK does not allow you to use a self-signed certificate to sign a manife
 
 For initial development and testing, the SDK provides example *test certificates* and private keys:
 - The [Rust library `sdk/tests/fixtures/certs/` folder](https://github.com/contentauth/c2pa-rs/tree/main/sdk/tests/fixtures/certs) contains certificates and signing keys for many of the supported [signature types](get-cert.md#signature-types).
-- The prerelease libraries (Node.js, Python, and C++) provide a subset of test certificates in each repository's `tests/fixtures` folder. The Node.js library even provides a [`CreateTestSigner()`](https://github.com/contentauth/c2pa-node/blob/main/docs/README.md#createtestsigner) convenience function to create a local signer instance using the test certificate.
+- The Node.js, Python, and C++ libraries provide a subset of test certificates in each repository's `tests/fixtures` folder. The Node.js library even provides a [`CreateTestSigner()`](https://github.com/contentauth/c2pa-node/blob/main/docs/README.md#createtestsigner) convenience function to create a local signer instance using the test certificate.
 
 :::warning Warning
 While these test credentials are useful during development, you must [get your own certificate](get-cert.md) and use your own private key for production deployment.