From a964d566ef2060d0a2a28d42d969da6fccd5c413 Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Fri, 21 Feb 2025 16:09:48 -0800
Subject: [PATCH 01/12] Render soft bing alg list into table view

---
 docs/soft-bindings.mdx        |  15 ++++
 sidebars.js                   |   5 ++
 src/components/JSONToTable.js |  96 +++++++++++++++++++++
 static/sb-alg-list.json       | 158 ++++++++++++++++++++++++++++++++++
 4 files changed, 274 insertions(+)
 create mode 100644 docs/soft-bindings.mdx
 create mode 100644 src/components/JSONToTable.js
 create mode 100644 static/sb-alg-list.json

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
new file mode 100644
index 0000000..0568011
--- /dev/null
+++ b/docs/soft-bindings.mdx
@@ -0,0 +1,15 @@
+---
+id: sb-algs
+title: Soft binding algorithm list
+hide_table_of_contents: true
+---
+
+C2PA specifies a mechanism for recovering a C2PA Manifest for an asset, for example when the metadata containing the C2PA Manifest has been stripped. This mechanism is a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_binding) (for example an invisible watermark or content fingerprint). The soft binding is used to look-up the C2PA Manifest within a Manifest Repository. The soft binding is described by the [soft binding assertion](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings).
+
+The soft binding assertion contains a field `alg` that serves to uniquely identify the algorithm used to compute the soft binding. The Soft Binding Algorithm List is an authoritative list of soft binding algorithm names that may be used as identifiers within the `alg` field. Entries in the list also contain additional information on the algorithms.
+
+import JSONToTable from '@site/src/components/JSONToTable';
+
+This table is generated from a static JSON file.
+
+<JSONToTable />
diff --git a/sidebars.js b/sidebars.js
index 168ed59..1201040 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -267,6 +267,11 @@ const sidebars = {
       label: 'Task planning & roadmap',
       id: 'roadmap',
     },
+    {
+      type: 'doc',
+      label: 'Soft binding algorithm list',
+      id: 'sb-algs',
+    },
   ],
 };
 
diff --git a/src/components/JSONToTable.js b/src/components/JSONToTable.js
new file mode 100644
index 0000000..13ebfef
--- /dev/null
+++ b/src/components/JSONToTable.js
@@ -0,0 +1,96 @@
+import React, { useState, useEffect } from 'react';
+
+// Helper function to flatten nested objects
+const flattenObject = (obj, prefix = '') => {
+  let result = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const newKey = prefix ? `${prefix}.${key}` : key;
+
+      // Handle nested objects
+      if (typeof obj[key] === 'object' && obj[key] !== null) {
+        if (Array.isArray(obj[key])) {
+          // If it's an array, join its elements into a comma-delimited string
+          result[newKey] = obj[key].join(', ');
+        } else {
+          // If it's an object, recurse to flatten it
+          Object.assign(result, flattenObject(obj[key], newKey));
+        }
+      } else {
+        result[newKey] = obj[key];
+      }
+    }
+  }
+  return result;
+};
+
+const JSONToTable = () => {
+  const [jsonData, setJsonData] = useState(null);
+  const [error, setError] = useState(null);
+
+  // Fetch the JSON data when the component mounts
+  useEffect(() => {
+    fetch('/sb-alg-list.json') // Path to the JSON file in the static folder
+      .then((response) => {
+        if (!response.ok) {
+          throw new Error('Failed to fetch the JSON file');
+        }
+        return response.json();
+      })
+      .then((data) => {
+        setJsonData(data);
+        setError(null); // Clear any previous errors
+      })
+      .catch((err) => {
+        setError(err.message);
+        setJsonData(null); // Reset data in case of error
+      });
+  }, []);
+
+  // Function to generate table headers dynamically
+  const generateTableHeaders = (data) => {
+    if (data && Array.isArray(data)) {
+      const flattenedData = data.map((item) => flattenObject(item));
+      const keys = Array.from(new Set(flattenedData.flatMap(Object.keys)));
+      return keys.map((key) => <th key={key}>{key}</th>);
+    }
+    return [];
+  };
+
+  // Function to generate table rows dynamically
+  const generateTableRows = (data) => {
+    console.log(data);
+    if (data && Array.isArray(data)) {
+      const flattenedData = data.map((item) => flattenObject(item));
+      return flattenedData.map((row, rowIndex) => (
+        <tr key={rowIndex}>
+          {Object.values(row).map((value, index) => (
+            <td key={index}>{value}</td>
+          ))}
+        </tr>
+      ));
+    }
+    return [];
+  };
+
+  return (
+    <div>
+      {error && <p style={{ color: 'red' }}>{error}</p>}
+
+      {jsonData && Array.isArray(jsonData) && (
+        <table border="1" style={{ width: '100%', borderCollapse: 'collapse' }}>
+          <thead>
+            <tr>{generateTableHeaders(jsonData)}</tr>
+          </thead>
+          <tbody>{generateTableRows(jsonData)}</tbody>
+        </table>
+      )}
+
+      {jsonData && !Array.isArray(jsonData) && (
+        <p>No data found in the JSON. Expected an array of objects.</p>
+      )}
+    </div>
+  );
+};
+
+export default JSONToTable;
diff --git a/static/sb-alg-list.json b/static/sb-alg-list.json
new file mode 100644
index 0000000..7db386d
--- /dev/null
+++ b/static/sb-alg-list.json
@@ -0,0 +1,158 @@
+[
+  {
+    "identifier": 1,
+    "alg": "com.digimarc.validate.1",
+    "type": "watermark",
+    "decodedMediaTypes": ["audio", "video", "text", "image"],
+    "entryMetadata": {
+      "description": "Digimarc Validate Digital Watermarking algorithm",
+      "dateEntered": "2024-05-17T17:00:00.000Z",
+      "contact": "info@digimarc.com",
+      "informationalUrl": "https://www.digimarc.com/products/digital-content-authentication"
+    }
+  },
+  {
+    "identifier": 2,
+    "alg": "org.atsc.a336",
+    "type": "watermark",
+    "decodedMediaTypes": ["audio", "video", "image"],
+    "entryMetadata": {
+      "description": "ATSC watermarking (A/334, A/335, A/336)",
+      "dateEntered": "2024-05-17T15:43:00.000Z",
+      "contact": "atsc@atsc.org",
+      "informationalUrl": "https://www.atsc.org/atsc-documents/a3362017-content-recovery-redistribution-scenarios/"
+    }
+  },
+  {
+    "identifier": 3,
+    "alg": "io.iscc.v0",
+    "type": "fingerprint",
+    "decodedMediaTypes": ["text", "image", "audio", "video", "application"],
+    "entryMetadata": {
+      "description": "ISO 24138 - International Standard Content Code (ISCC) V0 algorithm",
+      "dateEntered": "2024-05-17T16:00:00Z",
+      "contact": "info@iscc.io",
+      "informationalUrl": "https://www.iso.org/standard/77899.html"
+    }
+  },
+  {
+    "identifier": 4,
+    "alg": "com.adobe.trustmark.Q",
+    "type": "watermark",
+    "decodedMediaTypes": ["image"],
+    "entryMetadata": {
+      "description": "Adobe Trustmark variant Q",
+      "dateEntered": "2024-05-17T17:00:00.000Z",
+      "contact": "collomos@adobe.com",
+      "informationalUrl": "https://github.com/adobe/trustmark/"
+    }
+  },
+  {
+    "identifier": 5,
+    "alg": "com.adobe.trustmark.C",
+    "type": "watermark",
+    "decodedMediaTypes": ["image"],
+    "entryMetadata": {
+      "description": "Adobe Trustmark variant C",
+      "dateEntered": "2024-05-17T17:00:00.000Z",
+      "contact": "collomos@adobe.com",
+      "informationalUrl": "https://github.com/adobe/trustmark/"
+    }
+  },
+  {
+    "identifier": 6,
+    "alg": "com.adobe.icn.dense",
+    "type": "fingerprint",
+    "decodedMediaTypes": ["image"],
+    "entryMetadata": {
+      "description": "Adobe Image Comparator Network Dense Fingerprint",
+      "dateEntered": "2024-05-17T17:00:00.000Z",
+      "contact": "collomos@adobe.com",
+      "informationalUrl": "https://openaccess.thecvf.com/content/CVPR2021W/WMF/html/Black_Deep_Image_Comparator_Learning_To_Visualize_Editorial_Change_CVPRW_2021_paper.html"
+    }
+  },
+  {
+    "identifier": 7,
+    "alg": "ai.steg.api",
+    "type": "watermark",
+    "decodedMediaTypes": ["image", "video", "application"],
+    "entryMetadata": {
+      "description": "Steg.AI invisible watermarking",
+      "dateEntered": "2024-05-20T10:50:00.000Z",
+      "contact": "info@steg.ai",
+      "informationalUrl": "https://openaccess.thecvf.com/content_CVPR_2019/papers/Wengrowski_Light_Field_Messaging_With_Deep_Photographic_Steganography_CVPR_2019_paper.pdf"
+    }
+  },
+  {
+    "identifier": 8,
+    "alg": "ai.trufo.gen1.image",
+    "type": "watermark",
+    "decodedMediaTypes": ["image"],
+    "entryMetadata": {
+      "description": "Trufo image watermark.",
+      "dateEntered": "2024-08-14T15:00:00.000Z",
+      "contact": "tech@trufo.ai",
+      "informationalUrl": "https://trufo.ai/publications/"
+    }
+  },
+  {
+    "identifier": 9,
+    "alg": "ai.trufo.gen1.image-lite",
+    "type": "watermark",
+    "decodedMediaTypes": ["image"],
+    "entryMetadata": {
+      "description": "Trufo image watermark (lite version).",
+      "dateEntered": "2024-08-14T15:00:00.000Z",
+      "contact": "tech@trufo.ai",
+      "informationalUrl": "https://trufo.ai/publications/"
+    }
+  },
+  {
+    "identifier": 10,
+    "alg": "app.overlai.watermark.1",
+    "type": "watermark",
+    "decodedMediaTypes": ["image"],
+    "entryMetadata": {
+      "description": "Overlai Watermark version 1",
+      "dateEntered": "2024-08-14T16:00:00.000Z",
+      "contact": "luke@overlai.app",
+      "informationalUrl": "https://overlai.app/watermark"
+    }
+  },
+  {
+    "identifier": 11,
+    "alg": "tv.kinetiq.watercast.48.1",
+    "type": "watermark",
+    "decodedMediaTypes": ["video"],
+    "entryMetadata": {
+      "description": "Teletrax Watermarking algorithm",
+      "dateEntered": "2024-10-16T17:00:00.000Z",
+      "contact": "c2pa@kinetiq.tv",
+      "informationalUrl": "https://kinetiq.tv/broadcasting-syndication/"
+    }
+  },
+  {
+    "identifier": 12,
+    "alg": "castLabs.watermark.1",
+    "type": "watermark",
+    "decodedMediaTypes": ["video"],
+    "entryMetadata": {
+      "description": "castLabs Single Frame Forensic Watermarking",
+      "dateEntered": "2024-11-13T12:00:00.000Z",
+      "contact": "info@castlabs.com",
+      "informationalUrl": "https://castlabs.com/image-watermarking/"
+    }
+  },
+  {
+    "identifier": 13,
+    "alg": "com.adobe.trustmark.P",
+    "type": "watermark",
+    "decodedMediaTypes": ["image"],
+    "entryMetadata": {
+      "description": "Adobe Trustmark variant P",
+      "dateEntered": "2025-02-05T17:00:00.000Z",
+      "contact": "collomos@adobe.com",
+      "informationalUrl": "https://github.com/adobe/trustmark/"
+    }
+  }
+]

From d874ce0d34c20ea6678b7983862b71c74db38d7f Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Sat, 22 Feb 2025 12:04:24 -0800
Subject: [PATCH 02/12] Initial impl of displaying c2pa sba algo list.

---
 docs/soft-bindings.mdx        |   8 +-
 src/components/JSONToTable.js | 144 +++++++++++++++++++++-------------
 2 files changed, 93 insertions(+), 59 deletions(-)

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
index 0568011..2551a80 100644
--- a/docs/soft-bindings.mdx
+++ b/docs/soft-bindings.mdx
@@ -4,12 +4,12 @@ title: Soft binding algorithm list
 hide_table_of_contents: true
 ---
 
-C2PA specifies a mechanism for recovering a C2PA Manifest for an asset, for example when the metadata containing the C2PA Manifest has been stripped. This mechanism is a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_binding) (for example an invisible watermark or content fingerprint). The soft binding is used to look-up the C2PA Manifest within a Manifest Repository. The soft binding is described by the [soft binding assertion](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings).
+Durable Content Credentials is a concept that allows for the use of a variety of watermarking and fingerprinting approaches.
 
-The soft binding assertion contains a field `alg` that serves to uniquely identify the algorithm used to compute the soft binding. The Soft Binding Algorithm List is an authoritative list of soft binding algorithm names that may be used as identifiers within the `alg` field. Entries in the list also contain additional information on the algorithms.
+As described in the C2PA specification, a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings) such as an invisible watermark or content fingerprint provides a mechanism to recover an asset's manifest if the metadata containing the manifest has been stripped. The soft binding is used to look up the manifest within a manifest repository. The soft binding is described by the [soft binding assertion](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings).
 
-import JSONToTable from '@site/src/components/JSONToTable';
+The information below is from [C2PA's authoritative list of soft binding algorithms](https://github.com/c2pa-org/softbinding-algorithm-list).
 
-This table is generated from a static JSON file.
+import JSONToTable from '@site/src/components/JSONToTable';
 
 <JSONToTable />
diff --git a/src/components/JSONToTable.js b/src/components/JSONToTable.js
index 13ebfef..2e13ef7 100644
--- a/src/components/JSONToTable.js
+++ b/src/components/JSONToTable.js
@@ -1,36 +1,47 @@
 import React, { useState, useEffect } from 'react';
 
-// Helper function to flatten nested objects
-const flattenObject = (obj, prefix = '') => {
-  let result = {};
-  for (const key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      const newKey = prefix ? `${prefix}.${key}` : key;
+// Define the fields to display and their custom headers
+const DISPLAY_FIELDS = {
+  alg: 'Algorithm Name',
+  decodedMediaTypes: 'Media Types',
+  'entryMetadata.informationalUrl': 'URL',
+  'entryMetadata.contact': 'Contact',
+};
 
-      // Handle nested objects
-      if (typeof obj[key] === 'object' && obj[key] !== null) {
-        if (Array.isArray(obj[key])) {
-          // If it's an array, join its elements into a comma-delimited string
-          result[newKey] = obj[key].join(', ');
-        } else {
-          // If it's an object, recurse to flatten it
-          Object.assign(result, flattenObject(obj[key], newKey));
-        }
-      } else {
-        result[newKey] = obj[key];
-      }
-    }
+// Helper function to safely extract nested values and flatten arrays
+const getNestedValue = (obj, path) => {
+  const value = path
+    .split('.')
+    .reduce(
+      (acc, key) => (acc && acc[key] !== undefined ? acc[key] : 'N/A'),
+      obj,
+    );
+  return Array.isArray(value) ? value.join(', ') : value; // Flatten arrays into a comma-separated string
+};
+
+// Function to extract and filter only the required fields
+const extractAndFilterObject = (obj) => {
+  let result = {};
+  for (const key in DISPLAY_FIELDS) {
+    result[key] = getNestedValue(obj, key);
   }
   return result;
 };
 
+// Helper function to capitalize each word in a string
+const capitalizeWords = (str) => {
+  return str
+    .split(' ')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+};
+
 const JSONToTable = () => {
   const [jsonData, setJsonData] = useState(null);
   const [error, setError] = useState(null);
 
-  // Fetch the JSON data when the component mounts
   useEffect(() => {
-    fetch('/sb-alg-list.json') // Path to the JSON file in the static folder
+    fetch('/sb-alg-list.json')
       .then((response) => {
         if (!response.ok) {
           throw new Error('Failed to fetch the JSON file');
@@ -39,56 +50,79 @@ const JSONToTable = () => {
       })
       .then((data) => {
         setJsonData(data);
-        setError(null); // Clear any previous errors
+        setError(null);
       })
       .catch((err) => {
         setError(err.message);
-        setJsonData(null); // Reset data in case of error
+        setJsonData(null);
       });
   }, []);
 
-  // Function to generate table headers dynamically
-  const generateTableHeaders = (data) => {
-    if (data && Array.isArray(data)) {
-      const flattenedData = data.map((item) => flattenObject(item));
-      const keys = Array.from(new Set(flattenedData.flatMap(Object.keys)));
-      return keys.map((key) => <th key={key}>{key}</th>);
-    }
-    return [];
+  // Function to group data by the 'type' field
+  const groupDataByType = (data) => {
+    return data.reduce((acc, item) => {
+      const type = getNestedValue(item, 'type');
+      if (!acc[type]) acc[type] = [];
+      acc[type].push(item);
+      return acc;
+    }, {});
+  };
+
+  const generateTableHeaders = () => {
+    return Object.keys(DISPLAY_FIELDS).map((key) => (
+      <th key={key}>{DISPLAY_FIELDS[key]}</th>
+    ));
   };
 
-  // Function to generate table rows dynamically
   const generateTableRows = (data) => {
-    console.log(data);
-    if (data && Array.isArray(data)) {
-      const flattenedData = data.map((item) => flattenObject(item));
-      return flattenedData.map((row, rowIndex) => (
+    return data.map((item, rowIndex) => {
+      const filteredData = extractAndFilterObject(item);
+      const url = filteredData['entryMetadata.informationalUrl'];
+      const description = getNestedValue(item, 'entryMetadata.description');
+
+      return (
         <tr key={rowIndex}>
-          {Object.values(row).map((value, index) => (
-            <td key={index}>{value}</td>
+          {Object.keys(DISPLAY_FIELDS).map((key, index) => (
+            <td key={index}>
+              {key === 'entryMetadata.informationalUrl' ? (
+                url !== 'N/A' && description !== 'N/A' ? (
+                  <a href={url} target="_blank" rel="noopener noreferrer">
+                    {description}
+                  </a>
+                ) : (
+                  'N/A'
+                )
+              ) : (
+                filteredData[key]
+              )}
+            </td>
           ))}
         </tr>
-      ));
-    }
-    return [];
+      );
+    });
   };
 
-  return (
-    <div>
-      {error && <p style={{ color: 'red' }}>{error}</p>}
+  if (error) return <p style={{ color: 'red' }}>{error}</p>;
 
-      {jsonData && Array.isArray(jsonData) && (
-        <table border="1" style={{ width: '100%', borderCollapse: 'collapse' }}>
-          <thead>
-            <tr>{generateTableHeaders(jsonData)}</tr>
-          </thead>
-          <tbody>{generateTableRows(jsonData)}</tbody>
-        </table>
-      )}
+  if (!jsonData || !Array.isArray(jsonData)) {
+    return <p>No data found in the JSON. Expected an array of objects.</p>;
+  }
+
+  const groupedData = groupDataByType(jsonData);
 
-      {jsonData && !Array.isArray(jsonData) && (
-        <p>No data found in the JSON. Expected an array of objects.</p>
-      )}
+  return (
+    <div>
+      {Object.entries(groupedData).map(([type, data]) => (
+        <div key={type} style={{ marginBottom: '30px' }}>
+          <h2>{capitalizeWords(type)} algorithms</h2>
+          <table style={{ borderCollapse: 'collapse' }}>
+            <thead>
+              <tr>{generateTableHeaders()}</tr>
+            </thead>
+            <tbody>{generateTableRows(data)}</tbody>
+          </table>
+        </div>
+      ))}
     </div>
   );
 };

From d9d326d932bbaae5b8c5781148249382eee26f5f Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Mon, 24 Feb 2025 17:04:50 -0800
Subject: [PATCH 03/12] Add dynamic fetch of soft binding alg list from c2pa
 github repo

---
 docs/soft-bindings.mdx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
index 2551a80..f7eae10 100644
--- a/docs/soft-bindings.mdx
+++ b/docs/soft-bindings.mdx
@@ -1,14 +1,14 @@
 ---
 id: sb-algs
-title: Soft binding algorithm list
+title: Watermarking and fingerprinting algorithms
 hide_table_of_contents: true
 ---
 
-Durable Content Credentials is a concept that allows for the use of a variety of watermarking and fingerprinting approaches.
+[Durable Content Credentials](https://contentauthenticity.org/blog/durable-content-credentials) combines Content Credentials secure metadata, undetectable watermarks, and content fingerprinting to make content provenance more robust than using just one of these methods.
 
-As described in the C2PA specification, a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings) such as an invisible watermark or content fingerprint provides a mechanism to recover an asset's manifest if the metadata containing the manifest has been stripped. The soft binding is used to look up the manifest within a manifest repository. The soft binding is described by the [soft binding assertion](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings).
+As described in the C2PA specification, if the metadata a manifest has been stripped from an asset, then you can use a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings) such as an invisible watermark or fingerprint to look up the manifest within a repository so it can be recovered.
 
-The information below is from [C2PA's authoritative list of soft binding algorithms](https://github.com/c2pa-org/softbinding-algorithm-list).
+The C2PA specification doesn't cover watermarking and fingerprinting techniques _per se_, rather it allows using a variety of approaches. The following table lists the algorithms approved by the C2PA Technical Working Group from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
 
 import JSONToTable from '@site/src/components/JSONToTable';
 

From 19990bd9b6a48620b89a779879cb18b7a572e0a4 Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Tue, 25 Feb 2025 10:17:26 -0800
Subject: [PATCH 04/12] Add alg list to fetch-readmes, move in sidebar

---
 scripts/fetch-readme.js |  5 +++++
 sidebars.js             | 18 +++++++++++-------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/scripts/fetch-readme.js b/scripts/fetch-readme.js
index 850add6..903baf2 100644
--- a/scripts/fetch-readme.js
+++ b/scripts/fetch-readme.js
@@ -189,6 +189,11 @@ const readmes = [
     repo: 'contentauth/c2pa-min',
     path: 'README.md',
   },
+  {
+    dest: resolve(__dirname, '../static/sb-alg-list.json'),
+    repo: 'c2pa-org/softbinding-algorithm-list',
+    path: 'softbinding-algorithm-list.json',
+  },
 ];
 
 function resolveMarkdownLinks(linkBase, content) {
diff --git a/sidebars.js b/sidebars.js
index 1201040..e618ab0 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -259,19 +259,23 @@ const sidebars = {
       id: 'faqs',
     },
     {
-      type: 'doc',
-      id: 'community-resources',
+      type: 'category',
+      label: 'Community resources',
+      link: { type: 'doc', id: 'community-resources' },
+      collapsed: true,
+      items: [
+        {
+          type: 'doc',
+          label: 'Watermarking and fingerprinting',
+          id: 'sb-algs',
+        },
+      ],
     },
     {
       type: 'doc',
       label: 'Task planning & roadmap',
       id: 'roadmap',
     },
-    {
-      type: 'doc',
-      label: 'Soft binding algorithm list',
-      id: 'sb-algs',
-    },
   ],
 };
 

From 437313d025dea3c223908603df7408546d9b0d59 Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Tue, 25 Feb 2025 10:24:53 -0800
Subject: [PATCH 05/12] Rewording

---
 docs/soft-bindings.mdx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
index f7eae10..c00acae 100644
--- a/docs/soft-bindings.mdx
+++ b/docs/soft-bindings.mdx
@@ -6,9 +6,9 @@ hide_table_of_contents: true
 
 [Durable Content Credentials](https://contentauthenticity.org/blog/durable-content-credentials) combines Content Credentials secure metadata, undetectable watermarks, and content fingerprinting to make content provenance more robust than using just one of these methods.
 
-As described in the C2PA specification, if the metadata a manifest has been stripped from an asset, then you can use a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings) such as an invisible watermark or fingerprint to look up the manifest within a repository so it can be recovered.
+As described in the C2PA specification, if manifest metadata has been stripped from an asset, then you can use a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings) such as an invisible watermark or fingerprint to look up the manifest within a repository so it can be recovered.
 
-The C2PA specification doesn't cover watermarking and fingerprinting techniques _per se_, rather it allows using a variety of approaches. The following table lists the algorithms approved by the C2PA Technical Working Group from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
+The C2PA specification doesn't require any specific watermarking or fingerprinting techniques, rather it allows using a variety of approaches. The following table lists the algorithms approved by the C2PA Technical Working Group from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
 
 import JSONToTable from '@site/src/components/JSONToTable';
 

From 03a6858dde36216b16ed64e82844fca8eaaaeada Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Wed, 26 Feb 2025 11:22:34 -0800
Subject: [PATCH 06/12] Wording

---
 docs/soft-bindings.mdx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
index c00acae..3628004 100644
--- a/docs/soft-bindings.mdx
+++ b/docs/soft-bindings.mdx
@@ -4,7 +4,7 @@ title: Watermarking and fingerprinting algorithms
 hide_table_of_contents: true
 ---
 
-[Durable Content Credentials](https://contentauthenticity.org/blog/durable-content-credentials) combines Content Credentials secure metadata, undetectable watermarks, and content fingerprinting to make content provenance more robust than using just one of these methods.
+[Durable Content Credentials](https://contentauthenticity.org/blog/durable-content-credentials) is a concept that combines C2PA secure metadata, undetectable watermarks, and content fingerprinting to make content provenance more robust than using just one of these methods.
 
 As described in the C2PA specification, if manifest metadata has been stripped from an asset, then you can use a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings) such as an invisible watermark or fingerprint to look up the manifest within a repository so it can be recovered.
 

From 13e07b9ca3be29cd70e490199f433565da5df58a Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Fri, 28 Feb 2025 11:57:30 -0800
Subject: [PATCH 07/12] Clarify wording

---
 docs/soft-bindings.mdx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
index 3628004..3e344e1 100644
--- a/docs/soft-bindings.mdx
+++ b/docs/soft-bindings.mdx
@@ -4,11 +4,11 @@ title: Watermarking and fingerprinting algorithms
 hide_table_of_contents: true
 ---
 
-[Durable Content Credentials](https://contentauthenticity.org/blog/durable-content-credentials) is a concept that combines C2PA secure metadata, undetectable watermarks, and content fingerprinting to make content provenance more robust than using just one of these methods.
+[_Durable Content Credentials_](https://contentauthenticity.org/blog/durable-content-credentials) is a concept that combines C2PA secure metadata, undetectable watermarks, and content fingerprinting to make content provenance more robust than using just one of these methods.
 
-As described in the C2PA specification, if manifest metadata has been stripped from an asset, then you can use a [soft binding](https://c2pa.org/specifications/specifications/2.0/specs/C2PA_Specification.html#_soft_bindings) such as an invisible watermark or fingerprint to look up the manifest within a repository so it can be recovered.
+In the C2PA specification, watermarks and content fingerprinting are known as [soft binding](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_bindings), which enable digital content to be matched even if the underlying bits differ. For example, if manifest metadata has been stripped from an asset, then you can use a soft binding to look up and recover the manifest from an online repository.
 
-The C2PA specification doesn't require any specific watermarking or fingerprinting techniques, rather it allows using a variety of approaches. The following table lists the algorithms approved by the C2PA Technical Working Group from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
+The C2PA specification requires that soft bindings be generated using one approved [soft binding algorithms](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_binding_algorithm_list). The following table lists the algorithms approved by the C2PA Technical Working Group from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
 
 import JSONToTable from '@site/src/components/JSONToTable';
 

From 169e6cb41e9de23455ad1d6a37790dcc531bc950 Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Fri, 28 Feb 2025 12:01:53 -0800
Subject: [PATCH 08/12] minor edits

---
 docs/soft-bindings.mdx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
index 3e344e1..03c1c42 100644
--- a/docs/soft-bindings.mdx
+++ b/docs/soft-bindings.mdx
@@ -6,9 +6,9 @@ hide_table_of_contents: true
 
 [_Durable Content Credentials_](https://contentauthenticity.org/blog/durable-content-credentials) is a concept that combines C2PA secure metadata, undetectable watermarks, and content fingerprinting to make content provenance more robust than using just one of these methods.
 
-In the C2PA specification, watermarks and content fingerprinting are known as [soft binding](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_bindings), which enable digital content to be matched even if the underlying bits differ. For example, if manifest metadata has been stripped from an asset, then you can use a soft binding to look up and recover the manifest from an online repository.
+In the C2PA specification, watermarks and content fingerprinting are known as [soft bindings](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_bindings), which enable digital content to be matched even if the underlying bits differ. For example, if manifest metadata has been stripped from an asset, then you can use a soft binding to look up and recover the manifest from an online repository.
 
-The C2PA specification requires that soft bindings be generated using one approved [soft binding algorithms](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_binding_algorithm_list). The following table lists the algorithms approved by the C2PA Technical Working Group from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
+The C2PA specification requires that soft bindings be generated using one of the [soft binding algorithms](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_binding_algorithm_list) approved by the C2PA Technical Working Group. The following table lists the algorithms from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
 
 import JSONToTable from '@site/src/components/JSONToTable';
 

From 0ca84c1356b24df4a165013f6df0959d2537f4a3 Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Mon, 3 Mar 2025 09:33:36 -0800
Subject: [PATCH 09/12] Remove static/sb-alg-list.json from PR and add to
 .gitignore. The fetch-readmes script gets it for build

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 0500d8a..a039e0d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,8 @@
 # Generated files
 .docusaurus
 .cache-loader
+
+# External files loaded by fetch-readmes script
 /docs/js-sdk/api
 /docs/js-sdk/examples/quickstart/*.ts
 /docs/js-sdk/examples/view-manifest/*.ts
@@ -23,6 +25,7 @@
 /docs/rust-sdk/*.md
 /docs/rust-sdk/docs/*.md
 /docs/**/readme.md
+/static/sb-alg-list.json
 
 # Misc
 .DS_Store

From dfa6bf773698db4984faa7a878b78cbb956ece66 Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Mon, 3 Mar 2025 14:15:26 -0800
Subject: [PATCH 10/12] Comments from John Collomosse

---
 docs/soft-bindings.mdx | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
index 03c1c42..8adceb3 100644
--- a/docs/soft-bindings.mdx
+++ b/docs/soft-bindings.mdx
@@ -4,11 +4,15 @@ title: Watermarking and fingerprinting algorithms
 hide_table_of_contents: true
 ---
 
-[_Durable Content Credentials_](https://contentauthenticity.org/blog/durable-content-credentials) is a concept that combines C2PA secure metadata, undetectable watermarks, and content fingerprinting to make content provenance more robust than using just one of these methods.
+[_Durable Content Credentials_](https://contentauthenticity.org/blog/durable-content-credentials) is a concept that helps content provenance to persist across content platforms by also using one or both:
 
-In the C2PA specification, watermarks and content fingerprinting are known as [soft bindings](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_bindings), which enable digital content to be matched even if the underlying bits differ. For example, if manifest metadata has been stripped from an asset, then you can use a soft binding to look up and recover the manifest from an online repository.
+- **Undetectable watermarks**, actively inserted into the content
+- **Content fingerprinting**, passively computed from the content.
 
-The C2PA specification requires that soft bindings be generated using one of the [soft binding algorithms](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_binding_algorithm_list) approved by the C2PA Technical Working Group. The following table lists the algorithms from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
+Platforms might remove C2PA metadata if they don't yet support the standard or if they use automated process to, for example, provide multiple resolutions of an image which they then serve over the Web. By storing a copy of the metadata in an online database, you can use a watermark or a fingerprint to find it again.
+Combining both watermark and fingerprints further improves the robustness of the provenance information.
+
+In the C2PA specification, watermarks and content fingerprinting are known as [soft bindings](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_bindings), which can be used to find digital content, even if the underlying bits differ. The C2PA specification requires that soft bindings be generated using one of the [algorithms](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_binding_algorithm_list) approved by the C2PA Technical Working Group. The following table lists the algorithms from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
 
 import JSONToTable from '@site/src/components/JSONToTable';
 

From 634ed1326c5332e6253839681f0e61a59dab400d Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Mon, 3 Mar 2025 15:57:19 -0800
Subject: [PATCH 11/12] Removed file that shouldn't have been commited in the
 first place

---
 static/sb-alg-list.json | 158 ----------------------------------------
 1 file changed, 158 deletions(-)
 delete mode 100644 static/sb-alg-list.json

diff --git a/static/sb-alg-list.json b/static/sb-alg-list.json
deleted file mode 100644
index 7db386d..0000000
--- a/static/sb-alg-list.json
+++ /dev/null
@@ -1,158 +0,0 @@
-[
-  {
-    "identifier": 1,
-    "alg": "com.digimarc.validate.1",
-    "type": "watermark",
-    "decodedMediaTypes": ["audio", "video", "text", "image"],
-    "entryMetadata": {
-      "description": "Digimarc Validate Digital Watermarking algorithm",
-      "dateEntered": "2024-05-17T17:00:00.000Z",
-      "contact": "info@digimarc.com",
-      "informationalUrl": "https://www.digimarc.com/products/digital-content-authentication"
-    }
-  },
-  {
-    "identifier": 2,
-    "alg": "org.atsc.a336",
-    "type": "watermark",
-    "decodedMediaTypes": ["audio", "video", "image"],
-    "entryMetadata": {
-      "description": "ATSC watermarking (A/334, A/335, A/336)",
-      "dateEntered": "2024-05-17T15:43:00.000Z",
-      "contact": "atsc@atsc.org",
-      "informationalUrl": "https://www.atsc.org/atsc-documents/a3362017-content-recovery-redistribution-scenarios/"
-    }
-  },
-  {
-    "identifier": 3,
-    "alg": "io.iscc.v0",
-    "type": "fingerprint",
-    "decodedMediaTypes": ["text", "image", "audio", "video", "application"],
-    "entryMetadata": {
-      "description": "ISO 24138 - International Standard Content Code (ISCC) V0 algorithm",
-      "dateEntered": "2024-05-17T16:00:00Z",
-      "contact": "info@iscc.io",
-      "informationalUrl": "https://www.iso.org/standard/77899.html"
-    }
-  },
-  {
-    "identifier": 4,
-    "alg": "com.adobe.trustmark.Q",
-    "type": "watermark",
-    "decodedMediaTypes": ["image"],
-    "entryMetadata": {
-      "description": "Adobe Trustmark variant Q",
-      "dateEntered": "2024-05-17T17:00:00.000Z",
-      "contact": "collomos@adobe.com",
-      "informationalUrl": "https://github.com/adobe/trustmark/"
-    }
-  },
-  {
-    "identifier": 5,
-    "alg": "com.adobe.trustmark.C",
-    "type": "watermark",
-    "decodedMediaTypes": ["image"],
-    "entryMetadata": {
-      "description": "Adobe Trustmark variant C",
-      "dateEntered": "2024-05-17T17:00:00.000Z",
-      "contact": "collomos@adobe.com",
-      "informationalUrl": "https://github.com/adobe/trustmark/"
-    }
-  },
-  {
-    "identifier": 6,
-    "alg": "com.adobe.icn.dense",
-    "type": "fingerprint",
-    "decodedMediaTypes": ["image"],
-    "entryMetadata": {
-      "description": "Adobe Image Comparator Network Dense Fingerprint",
-      "dateEntered": "2024-05-17T17:00:00.000Z",
-      "contact": "collomos@adobe.com",
-      "informationalUrl": "https://openaccess.thecvf.com/content/CVPR2021W/WMF/html/Black_Deep_Image_Comparator_Learning_To_Visualize_Editorial_Change_CVPRW_2021_paper.html"
-    }
-  },
-  {
-    "identifier": 7,
-    "alg": "ai.steg.api",
-    "type": "watermark",
-    "decodedMediaTypes": ["image", "video", "application"],
-    "entryMetadata": {
-      "description": "Steg.AI invisible watermarking",
-      "dateEntered": "2024-05-20T10:50:00.000Z",
-      "contact": "info@steg.ai",
-      "informationalUrl": "https://openaccess.thecvf.com/content_CVPR_2019/papers/Wengrowski_Light_Field_Messaging_With_Deep_Photographic_Steganography_CVPR_2019_paper.pdf"
-    }
-  },
-  {
-    "identifier": 8,
-    "alg": "ai.trufo.gen1.image",
-    "type": "watermark",
-    "decodedMediaTypes": ["image"],
-    "entryMetadata": {
-      "description": "Trufo image watermark.",
-      "dateEntered": "2024-08-14T15:00:00.000Z",
-      "contact": "tech@trufo.ai",
-      "informationalUrl": "https://trufo.ai/publications/"
-    }
-  },
-  {
-    "identifier": 9,
-    "alg": "ai.trufo.gen1.image-lite",
-    "type": "watermark",
-    "decodedMediaTypes": ["image"],
-    "entryMetadata": {
-      "description": "Trufo image watermark (lite version).",
-      "dateEntered": "2024-08-14T15:00:00.000Z",
-      "contact": "tech@trufo.ai",
-      "informationalUrl": "https://trufo.ai/publications/"
-    }
-  },
-  {
-    "identifier": 10,
-    "alg": "app.overlai.watermark.1",
-    "type": "watermark",
-    "decodedMediaTypes": ["image"],
-    "entryMetadata": {
-      "description": "Overlai Watermark version 1",
-      "dateEntered": "2024-08-14T16:00:00.000Z",
-      "contact": "luke@overlai.app",
-      "informationalUrl": "https://overlai.app/watermark"
-    }
-  },
-  {
-    "identifier": 11,
-    "alg": "tv.kinetiq.watercast.48.1",
-    "type": "watermark",
-    "decodedMediaTypes": ["video"],
-    "entryMetadata": {
-      "description": "Teletrax Watermarking algorithm",
-      "dateEntered": "2024-10-16T17:00:00.000Z",
-      "contact": "c2pa@kinetiq.tv",
-      "informationalUrl": "https://kinetiq.tv/broadcasting-syndication/"
-    }
-  },
-  {
-    "identifier": 12,
-    "alg": "castLabs.watermark.1",
-    "type": "watermark",
-    "decodedMediaTypes": ["video"],
-    "entryMetadata": {
-      "description": "castLabs Single Frame Forensic Watermarking",
-      "dateEntered": "2024-11-13T12:00:00.000Z",
-      "contact": "info@castlabs.com",
-      "informationalUrl": "https://castlabs.com/image-watermarking/"
-    }
-  },
-  {
-    "identifier": 13,
-    "alg": "com.adobe.trustmark.P",
-    "type": "watermark",
-    "decodedMediaTypes": ["image"],
-    "entryMetadata": {
-      "description": "Adobe Trustmark variant P",
-      "dateEntered": "2025-02-05T17:00:00.000Z",
-      "contact": "collomos@adobe.com",
-      "informationalUrl": "https://github.com/adobe/trustmark/"
-    }
-  }
-]

From 6196d793825f4a5e493170ca26e888a408370153 Mon Sep 17 00:00:00 2001
From: Rand McKinney <crandmck@yahoo.com>
Date: Mon, 3 Mar 2025 16:23:59 -0800
Subject: [PATCH 12/12] Comments from LR

---
 docs/soft-bindings.mdx | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/docs/soft-bindings.mdx b/docs/soft-bindings.mdx
index 8adceb3..78693a2 100644
--- a/docs/soft-bindings.mdx
+++ b/docs/soft-bindings.mdx
@@ -4,16 +4,20 @@ title: Watermarking and fingerprinting algorithms
 hide_table_of_contents: true
 ---
 
-[_Durable Content Credentials_](https://contentauthenticity.org/blog/durable-content-credentials) is a concept that helps content provenance to persist across content platforms by also using one or both:
+[_Durable Content Credentials_](https://contentauthenticity.org/blog/durable-content-credentials) is a concept that helps content provenance to persist across content platforms by also:
 
-- **Undetectable watermarks**, actively inserted into the content
+- **Invisible watermarks**, actively inserted into the content
 - **Content fingerprinting**, passively computed from the content.
 
-Platforms might remove C2PA metadata if they don't yet support the standard or if they use automated process to, for example, provide multiple resolutions of an image which they then serve over the Web. By storing a copy of the metadata in an online database, you can use a watermark or a fingerprint to find it again.
+Platforms might remove C2PA manifest data, if, for example, they use software that does not yet support the standard. By storing a copy of the manifest data in an online database, you can use a watermark or a fingerprint to find it again.
 Combining both watermark and fingerprints further improves the robustness of the provenance information.
 
 In the C2PA specification, watermarks and content fingerprinting are known as [soft bindings](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_bindings), which can be used to find digital content, even if the underlying bits differ. The C2PA specification requires that soft bindings be generated using one of the [algorithms](https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_soft_binding_algorithm_list) approved by the C2PA Technical Working Group. The following table lists the algorithms from the [C2PA Soft Binding Algorithm List](https://github.com/c2pa-org/softbinding-algorithm-list).
 
+:::note
+The table below is provided **for information only** and is created and automatically updated based on data from the C2PA [softbinding-algorithm-list](https://github.com/c2pa-org/softbinding-algorithm-list/blob/main/softbinding-algorithm-list.json) repository, which is the single authoritative source of the information.
+:::
+
 import JSONToTable from '@site/src/components/JSONToTable';
 
 <JSONToTable />