Abstract

Capsium is a modular framework designed to efficiently and securely interchange multi-format information in interoperable portable packages, as well as platform-independent deployment of these packages to serve information consumers.

This document specifies requirements of the Capsium framework and its components:

1.  Scope

This document describes Capsium, a modular framework for the secure and efficient interchange of multi-format information within interoperable and portable packages.

This document specifies requirements of the Capsium framework and its components:

This document also provides:

2.  Normative references

The following documents are referred to in the text in such a way that some or all of their content constitutes requirements of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.

ISO/IEC 21320-1:2015, International Organization for Standardization (committee). Information technology — Document Container File — Part 1: Core. First edition. 2015. Geneva: International Organization for Standardization and International Electrotechnical Commission. https://www.iso.org/standard/60101.html.

NIST FIPS 180-4 fpd, National Institute of Standards and Technology. Secure Hash Standard (SHS). Edition Revision 4. 2012. Gaithersburg. https://csrc.nist.gov/pubs/fips/180-4/final.

NIST SP 800-38D fpd, DWORKIN, Morris. Recommendation for Block Cipher Modes of Operation — Galois/Counter Mode (GCM) and GMAC. 2007. Gaithersburg. https://csrc.nist.gov/pubs/sp/800/38/d/final.

IETF RFC 8017, KALISKI, B., J. JONSSON and A. RUSCH. PKCS #1: RSA Cryptography Specifications Version 2.2. 2016. RFC Publisher. https://www.rfc-editor.org/info/rfc8017.

IETF RFC 9110, Internet Engineering Task Force (committee). HTTP Semantics. 2022. RFC Publisher. https://www.rfc-editor.org/info/rfc9110.

SemVer 2.0.0, Semantic Versioning 2.0.0. https://semver.org/spec/v2.0.0.html

SPDX License List, SPDX License List. Linux Foundation. https://spdx.org/licenses/

3.  Terms and definitions

For the purposes of this document, the following terms and definitions apply.

3.1. Capsium package

A structured bundle of multi-format data and resources that can be securely and efficiently interchanged and deployed across different platforms. Capsium packages are designed to be portable and interoperable, ensuring seamless data transfer and application deployment.

3.2. Capsium reactor

A component responsible for managing and deploying Capsium packages. The Capsium reactor can be implemented directly by a web browser or installed on user machines or servers. It eliminates the need for a traditional web server by mimicking its file-serving capabilities.

3.3. Capsium HTTP API

3.4. Non-application website

A website that does not require server-side logic or dynamic content generation. These websites consist primarily of static resources such as HTML, CSS, and JavaScript files and are deployed using the Capsium framework without the need for a traditional web server.

3.5. Single-page application (SPA)

A web application that loads a single HTML page and dynamically updates the content as the user interacts with the app. SPAs provide a more fluid and responsive user experience by reducing server dependency. Capsium supports the deployment and optimization of SPAs.

3.6. Data immutability

The property of data that ensures it remains unchanged and secure from tampering after it has been created. Capsium guarantees data immutability through the use of advanced cryptographic techniques, ensuring the integrity and trustworthiness of the data.

3.7. Interoperability

The ability of different systems, platforms, and applications to communicate and work together effectively. Capsium supports a wide range of formats and protocols, enabling seamless data exchange and integration across diverse environments.

3.8. Portability

The capability of a system or application to be easily transferred and used across different environments without compromising security or functionality. Capsium packages are designed to be portable, facilitating easy migration and deployment.

3.9. Compliance and auditing

The adherence to regulatory requirements and the ability to track and monitor data access and modifications. Capsium includes features that ensure compliance with relevant standards and provide robust auditing capabilities to maintain data integrity and security.

3.10. Encryption

The process of converting data into a coded format to prevent unauthorized access. Capsium employs advanced encryption techniques to ensure that the data within its packages is securely stored and transferred, protecting sensitive information from breaches.

3.11. Key management

The administration of cryptographic keys, which includes their generation, exchange, storage, use, and replacement. In the context of Capsium, key management is crucial for maintaining the security of encrypted data and ensuring that only authorized entities can access or modify the data.

3.12. Static website

A website consisting of fixed content that does not change unless manually updated. Static websites are composed of HTML, CSS, and JavaScript files and do not require server-side processing. Capsium aids in the deployment of static websites by packaging all necessary resources into a single, portable bundle.

3.13. Virtualization

The creation of a virtual version of something, such as an operating system, a server, a storage device, or network resources. Capsium packages reduce the need for virtualization by allowing applications to run directly in the browser or on the client machine, simplifying deployment and reducing resource requirements.

3.14. Package management

The process of handling software packages, including their installation, upgrade, configuration, and removal. Capsium’s package management capabilities ensure that Capsium packages can be efficiently deployed and maintained, streamlining the application lifecycle.

3.15. Browser-implemented reactor

A Capsium reactor that is directly implemented by the web browser, enabling it to serve Capsium packages without the need for additional server infrastructure. This approach leverages the browser’s native capabilities to handle package deployment and management.

3.16. Serverless architecture

A design pattern where the server management and infrastructure concerns are abstracted away from the developer. Capsium supports serverless architectures by allowing applications to be deployed and run without a traditional server, relying instead on the Capsium reactor.

3.17. Cryptographic techniques

Methods used to secure information and communications through the use of codes, ensuring that only those for whom the information is intended can read and process it. Capsium utilizes cryptographic techniques to maintain data security and integrity within its packages.

3.18. Interchange format

A standardized format used for exchanging data between different systems or platforms. Capsium defines a specific interchange format to ensure that its packages can be seamlessly transferred and utilized across various environments.

3.19. Multi-format information

Data that exists in various formats, such as text, images, video, and structured data. Capsium packages are designed to handle multi-format information, ensuring that diverse types of data can be securely and efficiently bundled together and deployed.

3.20. Deployment

The process of distributing and installing software or data packages in a specific environment. Capsium streamlines deployment by allowing packages to be easily transferred and installed without the need for extensive configuration or server infrastructure.

3.21. Regulatory compliance

Adhering to laws, regulations, and guidelines relevant to the handling and protection of data. Capsium helps organizations maintain regulatory compliance by providing tools and features that ensure data security, integrity, and traceability.

3.22. File-serving capabilities

The ability of a server or system to deliver files to clients upon request. In the context of Capsium, the reactor mimics traditional file-serving capabilities, allowing it to serve packaged resources directly to the browser or client machine.

3.23. Resource bundling

The process of combining multiple files and resources into a single package. Capsium facilitates resource bundling, enabling efficient transfer and deployment of all necessary components of a web application or website.

3.24. Package integrity

The assurance that a package has not been altered or tampered with since its creation. Capsium ensures package integrity through cryptographic signatures and other security measures, guaranteeing that the contents of a package remain unchanged during transfer and deployment.

3.25. Transferability

The ease with which data or applications can be moved from one environment to another. Capsium enhances transferability by providing a standardized package format that can be easily migrated across different platforms and systems.

3.26. Static content

Web content that does not change and is delivered to the user exactly as stored. Capsium supports the deployment of static content by packaging it into a portable format that can be served without the need for dynamic processing.

3.27. Advanced cryptography

The use of sophisticated encryption algorithms and techniques to protect data. Capsium employs advanced cryptography to ensure that the data within its packages is secure from unauthorized access and tampering.

3.28. Data migration

The process of moving data from one system or environment to another. Capsium simplifies data migration by providing a portable package format that facilitates the transfer of data and resources across different platforms.

3.29. Scalable deployment

The ability to efficiently deploy applications and data across a varying number of environments and users. Capsium supports scalable deployment by providing a flexible package format and reactor that can handle deployments of any size.

3.30. Platform independence

The ability of software or data to operate on various hardware and operating systems without requiring modification. Capsium ensures platform independence by using standardized formats and protocols, allowing its packages to be used across different environments seamlessly.

3.31. Dependency management

The process of handling and resolving the dependencies required by software applications or packages. Capsium includes mechanisms for managing dependencies within its packages, ensuring that all necessary components are available and properly configured during deployment.

3.32. Immutable data

Data that cannot be altered once it has been created. Capsium guarantees immutability through cryptographic methods, making sure that data within a package remains unchanged and secure from tampering.

3.33. Data integrity

The accuracy and consistency of data over its lifecycle. Capsium ensures data integrity by using cryptographic techniques to protect data from unauthorized alterations, ensuring reliable and trustworthy information.

3.34. Secure interchange

The safe and protected exchange of data between different systems or platforms. Capsium facilitates secure interchange by using advanced encryption and ensuring that packages are transferred without compromising their integrity or confidentiality.

3.35. Application lifecycle

The entire process of developing, deploying, maintaining, and eventually decommissioning an application. Capsium supports the application lifecycle by providing tools and features that streamline deployment, maintenance, and updates of packaged applications.

3.36. Server dependency

The reliance on a server to provide resources, process requests, and manage data. Capsium reduces server dependency by enabling applications and websites to be deployed and run using the Capsium reactor, which can function without a traditional server.

3.37. Resource optimization

The process of improving the efficiency and performance of resources used by an application or system. Capsium supports resource optimization by packaging resources in a way that reduces load times and minimizes server demands.

3.38. Data traceability

The ability to track the history, usage, and location of data over its lifecycle. Capsium includes features that enhance data traceability, ensuring that data access and modifications can be monitored and audited for compliance and security purposes.

3.39. Data security

The protection of data from unauthorized access, corruption, or theft. Capsium ensures data security through encryption, key management, and other protective measures, maintaining the confidentiality and integrity of packaged data.

3.40. Audit trail

A record of all actions and changes made to data, providing transparency and accountability. Capsium supports the creation of audit trails, helping organizations monitor data access and modifications for compliance and security.

3.41. Browser-native deployment

The ability to deploy applications and resources directly within a web browser without requiring additional plugins or software. Capsium supports browser-native deployment, leveraging the browser’s capabilities to handle and serve packaged data and applications.

3.42. Dynamic content

Web content that changes based on user interactions or other conditions. While Capsium primarily targets static and SPA content, it can support dynamic content through appropriate integration with client-side scripting.

3.43. Lightweight deployment

A deployment method that minimizes resource usage and overhead, making it suitable for environments with limited resources. Capsium supports lightweight deployment by packaging applications and data in an efficient, compact format.

3.44. Multi-platform support

The ability to operate across various operating systems, devices, and environments. Capsium ensures multi-platform support by adhering to standardized formats and protocols, allowing its packages to function seamlessly across different systems.

3.45. Portable package

A self-contained bundle that includes all necessary resources and data, designed to be easily transferred and deployed across different environments. Capsium packages are inherently portable, facilitating straightforward migration and deployment.

3.46. Client-side processing

The execution of operations on the user’s device rather than on a server. Capsium supports client-side processing by enabling web applications to run directly in the browser, reducing the need for server interactions.

3.47. Cross-platform compatibility

The ability of software or data to work on various operating systems and devices without requiring modifications. Capsium ensures cross-platform compatibility by using standardized formats and protocols, making its packages usable across different platforms.

3.48. Version control

A system for managing changes to documents, programs, and other information stored as computer files. Capsium integrates version control mechanisms to help track changes, manage different versions, and ensure consistency of packaged data.

3.49. Secure deployment

The practice of deploying applications and data in a manner that ensures their security throughout the process. Capsium supports secure deployment by using encryption and other security measures to protect packages from tampering and unauthorized access.

3.50. Configuration management

The process of handling changes in software, hardware, documentation, and other components. Capsium includes features for configuration management, ensuring that packages are correctly configured and maintained throughout their lifecycle.

3.51. Integrity check

A method to verify that data has not been altered or tampered with. Capsium performs integrity checks using cryptographic signatures, ensuring the authenticity and consistency of the data within its packages.

3.52. Modular framework

A design approach that divides a system into smaller parts, or modules, that can be independently created and then used in different systems. Capsium is a modular framework, allowing components to be added, removed, or updated without affecting the whole system.

3.53. User authentication

The process of verifying the identity of a user. Capsium supports user authentication to ensure that only authorized individuals can access and interact with the contents of a package.

3.54. Data encapsulation

The bundling of data with the methods that operate on that data, restricting direct access to some of the object’s components. Capsium utilizes data encapsulation to protect the integrity and security of the packaged data.

3.55. Environment abstraction

The separation of application logic from the underlying hardware and software environment. Capsium provides environment abstraction by allowing packages to operate independently of the specific details of the deployment environment.

3.56. Resilience

The ability of a system or application to recover quickly from failures and continue to function. Capsium enhances resilience by packaging applications in a way that minimizes dependencies and facilitates recovery and redeployment.

3.57. Scalability

The capacity to handle increasing amounts of work or to be readily enlarged. Capsium supports scalability by ensuring that its packages can be deployed and managed efficiently, regardless of the scale of the deployment.

3.58. Trusted execution

The assurance that code and data are executed in a secure environment, protected from unauthorized access and tampering. Capsium supports trusted execution through the use of secure packaging and deployment mechanisms.

3.59. Content delivery

The process of distributing digital content to users. Capsium optimizes content delivery by bundling resources into efficient packages that can be served directly by the browser or client machine.

3.60. Content encapsulation

The practice of bundling content with the necessary metadata and resources to ensure it can be used independently of its original environment. Capsium uses content encapsulation to create portable packages that can be deployed and used across different systems.

3.61. Application sandboxing

The technique of running applications in a restricted environment to limit their access to system resources and data. Capsium can support application sandboxing by enabling packages to run in isolated environments, enhancing security and control.

3.62. Metadata management

The process of handling metadata, which is data that describes other data. Capsium includes features for metadata management, ensuring that the necessary information about packaged data and resources is available and properly maintained.

3.63. Data lifecycle management

The process of managing data from its creation to its eventual disposal. Capsium includes features for data lifecycle management, ensuring that data within its packages is properly handled, maintained, and disposed of according to best practices and regulatory requirements.

4.  Capsium framework

The Capsium framework provides a comprehensive set of principles, features, and use cases that define its architecture and functionality. This clause outlines the essential components and concepts that make up the framework, ensuring a clear understanding of its capabilities and applications.

5.  Capsium package

The Capsium package is the fundamental unit of deployment within the Capsium framework. This clause details the structure, contents, and specifications of a Capsium package, ensuring a comprehensive understanding of its components and functionality.

example-capsium-package/
├── index.html
├── styles.css
├── app.js
├── manifest.json
├── routes.json
├── http-api.json
├── storage.json
├── security.json
├── authentication.json
├── logging-monitoring.json
├── validation.json
├── LICENSE.spdx
└── README.md

{
    "name": "example-capsium-package",
    "version": "1.0.0",
    "description": "A sample Capsium package that demonstrates resource bundling.",
 "guid": "example.com/example-capsium-package",
    "uuid": "123e4567-e89b-12d3-a456-426614174000",
    "author": "Your Name",
    "repository": {
        "type": "git",
        "url": "https://github.com/yourusername/example-capsium-package.git"
    },
    "dependencies": {
        "other-package.capsium": ">=1.0.0"
    },
    "license": "path/to/LICENSE.spdx",
    "readOnly": true,
    "modules": ["signatures", "layered-storage"]
}

"modules": ["signatures", "layered-storage"]

"guid": "capsium://example.com/package-name"

"guid": "https://example.com/packages/sample-package"

"guid": "http://myorganization.org/capsium/my-package"

"guid": "capsium://opensource.org/libs/lib-capsium"

{
    "dependencies": {
        "capsium://example.com/package-name": ">=1.0.0",
        "https://example.com/packages/another-package": "^2.1.0"
    }
}

{
    "version": "1.0.0"
}

{
    "dependencies": {
        "other-package.capsium": ">=1.0.0",
        "another-package.capsium": "^2.3.4"
    }
}

   "dependencies": {
       "capsium://example.com/package-name": ">=1.0.0"
   }

   "dependencies": {
       "https://example.com/packages/first-package": "^2.1.0",
       "capsium://another.com/second-package": "1.2.3"
   }

   "dependencies": {
       "capsium://example.org/dependency-package": ">=1.0.0 <2.0.0"
   }

   "dependencies": {
       "capsium://example.net/experimental-package": "1.0.0-beta.1"
   }

   "dependencies": {
       "https://example.com/special-package": "1.0.0+20130313144700"
   }

   "dependencies": {
       "capsium://example.org/multi-range-package": ">=1.0.0 <1.5.0 || >=2.0.0 <3.0.0"
   }

   "dependencies": {
       "capsium://example.com/wildcard-package": "*"
   }

   "dependencies": {
       "capsium://example.com/caret-package": "^1.2.3",
       "capsium://example.com/tilde-package": "~1.2.3"
   }

   "license": "MIT"

   "license": "LICENSE.spdx"

   "license": [
       {
           "type": "MIT",
           "condition": "Default license"
       },
       {
           "type": "Apache-2.0",
           "condition": "For use in commercial environments"
       }
   ]

   "license": [
       {
           "type": "MIT",
           "condition": "Default license"
       },
       {
           "type": "Custom-License",
           "file": "custom-license.spdx",
           "condition": "For internal use only"
       }
   ]

   "license": [
       {
           "type": "GPL-3.0-only",
           "condition": "When redistributed"
       },
       {
           "type": "LGPL-3.0-only",
           "condition": "When used as a library"
       }
   ]

SPDXVersion: SPDX-2.1
DataLicense: CC0-1.0
SPDXID: SPDXRef-DOCUMENT
DocumentName: example-capsium-package
DocumentNamespace: http://spdx.org/spdxdocs/example-capsium-package-abc123
Creator: Person: John Doe
Creator: Organization: Example Organization
Creator: Tool: SPDX-Tools-Version-2.1.0
Created: 2024-05-28T12:00:00Z
LicenseID: MIT
LicenseName: MIT License
LicenseText: |
    MIT License

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.

{
    "license": "path/to/LICENSE.spdx"
}

{
    "resources": {
        "index.html": {
            "type": "text/html",
            "version": "1.0.0"
        },
        "styles.css": {
            "type": "text/css",
            "version": "1.0.0"
        },
        "app.js": {
            "type": "application/javascript",
            "version": "1.0.0"
        },
        "dynamic-content.js": {
            "type": "application/javascript",
            "version": "1.0.0"
        },
        "mobile.css": {
            "type": "text/css",
            "version": "1.0.0"
        },
        "desktop.css": {
            "type": "text/css",
            "version": "1.0.0"
        },
        "images/small.jpg": {
            "type": "image/jpeg",
            "version": "1.0.0"
        },
        "images/medium.jpg": {
            "type": "image/jpeg",
            "version": "1.0.0"
        },
        "images/large.jpg": {
            "type": "image/jpeg",
            "version": "1.0.0"
        },
        "content/en/index.html": {
            "type": "text/html",
            "version": "1.0.0"
        },
        "content/en/about.html": {
            "type": "text/html",
            "version": "1.0.0"
        },
        "content/es/index.html": {
            "type": "text/html",
            "version": "1.0.0"
        },
        "content/es/about.html": {
            "type": "text/html",
            "version": "1.0.0"
        }
    }
}

     {
         "resources": [
             {
                 "path": "scripts/main.js",
                 "visibility": "exported"
             },
             {
                 "path": "styles/theme.css",
                 "visibility": "private"
             },
             {
                 "path": "images/logo.png",
                 "visibility": "exported"
             }
         ]
     }

     {
         "dependencies": {
             "capsium://example.com/capsium-core": "1.0.0"
         },
         "routes": [
             {
                 "path": "/vendor/core/main.js",
                 "resource": "capsium://example.com/capsium-core/scripts/main.js"
             }
         ]
     }

   {
       "index": "public/index.html"
   }

   {
       "index": "docs/main.html"
   }

   {
       "index": "web/index.html"
   }

   {
       "index": "dist/index.html"
   }

   {
       "index": "index.html"
   }

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Capsium Package</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <h1>Welcome to the Capsium Package</h1>
    <script src="app.js"></script>
</body>
</html>

example-capsium-package/
├── index.html
├── styles.css
├── app.js
├── dynamic-content.js
├── mobile.css
├── desktop.css
├── images/
│   ├── small.jpg
│   ├── medium.jpg
│   └── large.jpg
├── content/
│   ├── en/
│   │   ├── index.html
│   │   └── about.html
│   ├── es/
│   │   ├── index.html
│   │   └── about.html
├── metadata.json
├── manifest.json
├── routes.json
├── LICENSE.spdx
└── README.md

{
    "index": "index.html",
    "routes": [
        {
            "path": "/",
            "resource": "index.html"
        },
        {
            "path": "/styles.css",
            "resource": "styles.css"
        },
        {
            "path": "/app.js",
            "resource": "app.js"
        },
        {
            "path": "/images/small.jpg",
            "resource": "images/small.jpg"
        },
        {
            "path": "/data/users",
            "resource": "data/users.json"
        },
        {
            "path": "/data/products",
            "resource": "data/products.json"
        }
    ]
}

   {
       "index": "public/index.html"
   }

{
    "storage": {
        "dataSets": {
            "users": {
                "source": "db/users",
            },
            "products": {
                "source": "files/products.json",
            },
            "sales": {
                "source": "api/external/sales",
            }
        }
    }
}

{
    "routes": [
        {
            "route": "/api/v1/data/users",
            "dataset": "users"
        },
        {
            "route": "/api/v1/data/products",
            "dataset": "products"
        },
        {
            "route": "/api/v1/data/sales",
            "dataset": "sales"
        }
    ]
}

{
    "routes": {
        "/api/resource": {
            "GET": {
                "file": "handlers/getResource.js",
                "headers": {
                    "Content-Type": "application/json",
                    "Cache-Control": "no-cache",
                    "Access-Control-Allow-Origin": "*"
                }
            },
            "POST": {
                "file": "handlers/postResource.js",
                "headers": {
                    "Content-Type": "application/json",
                    "Access-Control-Allow-Origin": "*"
                }
            }
        }
    }
}

{
    "routes": {
        "/api/resource": {
            "GET": {
                "file": "handlers/getResource.js",
                "headersFile": "headers/getResourceHeaders.json"
            },
            "POST": {
                "file": "handlers/postResource.js",
                "headersFile": "headers/postResourceHeaders.json"
            }
        }
    }
}

{
    "Content-Type": "application/json",
    "Cache-Control": "no-cache",
    "Access-Control-Allow-Origin": "*"
}

{
    "Content-Type": "application/json",
    "Access-Control-Allow-Origin": "*"
}

     {
         "routes": [
             {
                 "path": "/api/public",
                 "handler": "publicHandler",
                 "visibility": "exported"
             },
             {
                 "path": "/api/private",
                 "handler": "privateHandler",
                 "visibility": "private"
             }
         ]
     }

{
    "storage": {
        "dataSets": {
            "users": {
                "source": "db/users",
            },
            "products": {
                "source": "files/products.json",
            },
            "sales": {
                "source": "api/external/sales",
            }
        }
    }
}

     Cache-Control: public, max-age=31536000

     {
         "static": {
             "path": "static",
             "url": "/static"
         }
     }

6.  Create new package structure

mkdir /new-package cp -r /original-package/* /new-package/

7.  Update metadata

jq ’.packages += [{”id”: “capsiumPkg2”, “actionHistoryLocation”: “/new-package/action-history”}]’ /new-package/storage.json > /new-package/storage_tmp.json mv /new-package/storage_tmp.json /new-package/storage.json

8.  Validate package

capsium-validate /new-package `

Additional considerations for creating a new external Capsium package:

Example of integrity check: `shell capsium-check-integrity /new-package `

Example of updating documentation: `markdown # Capsium Package Documentation

9.  Create composite package structure

mkdir /composite-package/internal cp -r /original-package/* /composite-package/internal/

10.  Update metadata

jq ’.packages += [{”id”: “compositeCapsiumPkg1”, “internalActionHistoryPath”: “internal/action-history”}]’ /composite-package/storage.json > /composite-package/storage_tmp.json mv /composite-package/storage_tmp.json /composite-package/storage.json

11.  Validate package

capsium-validate /composite-package `

Additional considerations for creating a composite Capsium package:

Example of dependency management: `json { “compositePackageId”: “compositeCapsiumPkg1”, “dependencies”: [ { “packageId”: “capsiumPkg1”, “version”: “1.0” } ], “internalActionHistoryPath”: “internal/action-history” } `

Example of namespace handling: `json { “datasetNamespaces”: { “capsiumPkg1”: “namespace1”, “compositeCapsiumPkg1”: “namespace2” } } `

Example of testing script: `shell # Test script for composite package capsium-test /composite-package