@ibgib/core-gib 0.0.4

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@ibgib/core-gib",
+  "version": "0.0.4",
+  "description": "ibgib core functionality, including base architecture for witnesses, spaces, apps, robbots, etc., as well as shared utility functions. Node v19+ needed for heavily-used isomorphic webcrypto hashing consumed in both node and browsers.",
+  "repository": {
+    "url": "https://github.com/wraiford/ibgib",
+    "type": "git"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://paypal.me/ibGib"
+  },
+  "main": "dist/index.mjs",
+  "scripts": {
+    "build": "npm run clean && tsc -b tsconfig.json --force",
+    "build:test": "npm run clean && tsc -b tsconfig.test.json --force",
+    "build:test:noclean": "tsc -b tsconfig.test.json --force",
+    "clean": "rm -rf ./dist",
+    "test": "npm run test:both",
+    "test:both": "npm run build:test && npm run test:node:nobuild && npm run test:browser:nobuild",
+    "man:test:both": "use this if you want to test in both node and browser contexts",
+    "test:node": "npm run build:test && npx jasmine --config=jasmine.json",
+    "man:test:node": "use this if you want to build+test in node",
+    "test:node:nobuild": "npx jasmine --config=jasmine.json",
+    "man:test:node:nobuild": "use this if you want to test in node but its already built",
+    "test:browser": "npm run build:test && npx jasmine-browser-runner runSpecs --config=jasmine-browser.json ",
+    "man:test:browser": "use this if you want to build+test only the browser context",
+    "test:browser:nobuild": "npx jasmine-browser-runner runSpecs --config=jasmine-browser.json ",
+    "man:test:browser:nobuild": "use this if you want to test only the browser context but its already built",
+    "test:browser:serve": "npm run build:test && npx jasmine-browser-runner serve --config=jasmine-browser.json ",
+    "man:test:browser:serve": "use this if you want to build+test in the browser and don't want the browser to close when your done. (i.e. you're debugging)",
+    "test:browser:serve:nobuild": "npx jasmine-browser-runner serve --config=jasmine-browser.json ",
+    "man:test:browser:serve:nobuild": "use this if you are troubleshooting existing dist output and don't want to overwrite those files. (and you're debugging in the browser)",
+    "pack": "npm pack --pack-destination=\"./published\"",
+    "prepare:publish": "npm run clean && npm version patch && npm run build && npm run pack",
+    "man:prepare:publish": "use this to patch > build > pack for publishing to npm repo"
+  },
+  "type": "module",
+  "keywords": [
+    "ibgib",
+    "dlt",
+    "blockchain",
+    "graph-database"
+  ],
+  "author": "William Raiford",
+  "license": "ISC",
+  "dependencies": {
+    "@ibgib/encrypt-gib": "^0.1.6",
+    "@ibgib/helper-gib": "^0.0.2",
+    "@ibgib/ts-gib": "^0.5.1",
+    "rxjs": "^7.8.0"
+  },
+  "devDependencies": {
+    "@types/jasmine": "^4.3.1",
+    "@types/node": "^16.11.6",
+    "jasmine": "^4.5.0",
+    "jasmine-browser-runner": "^1.3.0",
+    "jasmine-core": "^4.5.0",
+    "typescript": "^4.9.5"
+  },
+  "engines": {
+    "node": ">=19.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/assumptions.spec.mts

@@ -0,0 +1,45 @@
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+
+/**
+ * wrapper that uses crypto.subtle under the hood (i.e. doesn't hash using ts-gib)
+ *
+ * notes:
+ *
+ * * i did in fact copy this from ts-gib though, but we're testing simply that the
+ *   context (node/browser/whatever) has this since it's integral to all things ibgib.
+ */
+async function cryptoSubtleHash({
+    s,
+    algorithm = 'SHA-256',
+}: {
+    s: string,
+    algorithm?: string,
+}): Promise<string> {
+    let { subtle } = globalThis.crypto;
+    if (!s) { throw new Error(`[${cryptoSubtleHash.name}] s is required`) }
+    if (!algorithm) { throw new Error(`[${cryptoSubtleHash.name}] algorithm is required`) }
+    try {
+        const msgUint8 = new TextEncoder().encode(s);
+        const buffer = await subtle.digest(algorithm, msgUint8);
+        const asArray = Array.from(new Uint8Array(buffer));
+        return asArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    } catch (e) {
+        console.error(e.message ?? e);
+        throw e;
+    }
+}
+
+describe(`non-ts-gib isomorphic crypto hashing`, () => {
+
+    it(`should digest simple string consistently using crypto.subtle directly `, async () => {
+        let h = await cryptoSubtleHash({ s: '42' });
+        expect(h).withContext('42').toBe('73475cb40a568e8da8a045ced110137e159f890ac4da883b6b17dc651b3a8049');
+    });
+
+    it(`should digest simple stringified ibgib consistently using crypto.subtle directly `, async () => {
+        let ibgib: IbGib_V1 = { ib: 'ib', gib: 'gib' };
+        let h = await cryptoSubtleHash({ s: JSON.stringify(ibgib) }); // doesn't use ts-gib but consistent stringifying json is important
+        expect(h).withContext('ib^gib').toBe('cbad0694a257358c044611ea1fa88ace71a01a9b8409d2354d0387d8043f7671');
+    });
+
+});

package/src/common/aws-constants.mts

@@ -0,0 +1,5 @@
+/**
+ * @module aws-constants
+ *
+ * this is to be moved into the aws-dynamodb-sync-space-gib lib.
+ */

package/src/common/bin/bin-types.mts

@@ -0,0 +1,17 @@
+import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/index.mjs';
+
+/**
+ * For pic binaries, this is a base 64 encoded string of the pic's image data.
+
+ * @see {@link BinIbGib_V1}
+ */
+export type BinData_V1 = any;
+
+/**
+ * IbGib for a binary, which right now atow just means a pic.
+ *
+ * Also for now, BinIbGib has no rel8ns, only data.
+ *
+ * @see {@link BinData_V1}
+ */
+export interface BinIbGib_V1 extends IbGib_V1<any> { };

package/src/common/cache/cache-types.mts

@@ -0,0 +1,53 @@
+import { IbGibAddr } from '@ibgib/ts-gib';
+import { IbGib_V1, IB } from '@ibgib/ts-gib/dist/V1/index.mjs';
+
+
+export interface IbGibCacheInfo {
+  /**
+   * The "primary key" of the cache info. If {@link addrScope} is not provided,
+   * then atow this will be the only location information for the ibGib.
+   */
+  addr: IbGibAddr;
+  /**
+   * If provided, this will be used to identify the cache info in combination
+   * with the addr. Else, just the addr will be used.
+   *
+   * So, e.g., you may store an ibGib item by
+   * @example { addr: comment abc^123, addrScope: 'item', ibGib, other: item }
+   */
+  addrScope?: string;
+  /**
+   * ibGib reference.
+   */
+  ibGib: IbGib_V1;
+  /**
+   * Place to store additional associated cached data with the ibGib.
+   *
+   * ## driving use case
+   *
+   * I want to cache the entire IbGibItem for many IbGibComponentBase classes to
+   * speed up the entire loading (not just the loading of the ibGib property
+   * itself from storage).
+   *
+   * atow I'm storing a separate entry with addr + this.lc for using this other
+   * property.
+   */
+  other?: any;
+  tjpAddr?: IbGibAddr;
+  tjpIbGib?: IbGib_V1;
+}
+
+/**
+ * Using this for a quick implementation for caching.
+ *
+ * ## future
+ *
+ * change this to an ibgib (in memory) innerspace. then we can pass in
+ * the innerspace ibgib instead of just setting a property. this will make
+ * it more extensible in the future (i think...)
+ */
+export interface IbGibCacheService {
+  has({ addr, addrScope }: { addr: IbGibAddr, addrScope?: string }): Promise<boolean>;
+  put(info: IbGibCacheInfo): Promise<void>;
+  get({ addr, addrScope }: { addr: IbGibAddr, addrScope?: string }): Promise<IbGibCacheInfo | undefined>;
+}

package/src/common/comment/comment-constants.mts

@@ -0,0 +1,10 @@
+/**
+ * comment ibs atow are comment [commentText substring]
+ */
+export const DEFAULT_COMMENT_TEXT_IB_SUBSTRING_LENGTH = 20;
+/**
+ * comment ib can have additional metadata string,
+ *
+ * @example "comment thisisacomm here_is_addl_metadata"
+ */
+export const DEFAULT_COMMENT_METADATA_IB_SUBSTRING_LENGTH = 64;

package/src/common/comment/comment-helper.mts

@@ -0,0 +1,211 @@
+import { Ib, TransformResult } from '@ibgib/ts-gib';
+import { Factory_V1 as factory, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/index.mjs';
+
+
+import { IbGibSpaceAny } from '../../witness/space/space-base-v1.mjs';
+import { persistTransformResult } from '../../witness/space/space-helper.mjs';
+import { CommentData_V1, CommentIbGib_V1 } from './comment-types.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
+import { getSaferSubstring, getTimestamp, pretty } from '@ibgib/helper-gib';
+import { DEFAULT_COMMENT_METADATA_IB_SUBSTRING_LENGTH, DEFAULT_COMMENT_TEXT_IB_SUBSTRING_LENGTH } from './comment-constants.mjs';
+// import { getSaferSubstring } from './utils.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT || false;
+
+
+/**
+ * generates an ib based on the comment text.
+ *
+ * Basically this gets a short substring of the comment text and replaces
+ * any non alphanumeric characters.
+ *
+ * @param commentText comment text
+ * @returns comment ib for the given comment text
+ */
+export function getCommentIb({
+  commentText,
+  addlMetadataText,
+}: {
+  commentText: string;
+  /**
+   * Optional metadata string to be included in the comment's ib.
+   * Should be underscore-delimited but not a hard rule atow.
+   *
+   * @example "comment thisisacomm here_is_addl_metadata"
+   */
+  addlMetadataText?: string;
+}): string {
+  const lc = `[${getCommentIb.name}]`;
+  try {
+    if (!commentText) { throw new Error(`commentText required. (E: 22fdfd0aa0524a18b63a9405b312c99e)`); }
+
+    // get a safe slice of the comment text to add to the ib
+    const ibCommentText =
+      getSaferSubstring({
+        text: commentText,
+        length: DEFAULT_COMMENT_TEXT_IB_SUBSTRING_LENGTH,
+        replaceMap: { ['?']: '__qm__' }, // we want to preserve question marks for requests for robbots
+      });
+
+    if (addlMetadataText) {
+      if (addlMetadataText.length > DEFAULT_COMMENT_METADATA_IB_SUBSTRING_LENGTH) {
+        console.warn(`${lc} addlMetadataText (${addlMetadataText.length}) is too long. Max length: ${DEFAULT_COMMENT_METADATA_IB_SUBSTRING_LENGTH}`);
+      }
+      const ibCommentMetadata =
+        getSaferSubstring({ text: addlMetadataText, length: DEFAULT_COMMENT_METADATA_IB_SUBSTRING_LENGTH });
+      if (!ibCommentMetadata) { throw new Error(`(UNEXPECTED) addlMetadataText contains no safe characters? (E: dd03c578ada2836b05c94a4aa1785222)`); }
+      return `comment ${ibCommentText} ${ibCommentMetadata}`;
+    } else {
+      return `comment ${ibCommentText}`;
+    }
+
+  } catch (error) {
+    console.error(`${lc} ${error.message}`);
+    throw error;
+  }
+}
+
+export function parseCommentIb({
+  ib,
+}: {
+  ib: Ib,
+}): {
+  safeIbCommentText: string;
+  safeIbCommentMetadataText?: string;
+} {
+  const lc = `${parseCommentIb.name}]`;
+  try {
+    if (logalot) { console.log(`${lc} starting... (I: 1a16f5e3134599eeb585eae77ee6af22)`); }
+
+    if (!ib) { throw new Error(`ib required (E: d89f8c4df46b970585c82bc89c1c6322)`); }
+
+    let [_, safeIbCommentText, safeIbCommentMetadataText] = ib.split(' ');
+    // replaceMap: { ['?']: '__qm__' }, // we want to preserve question marks for requests for robbots
+    while (safeIbCommentText.includes('__qm__')) {
+      safeIbCommentText = safeIbCommentText.replace('__qm__', '?');
+    }
+    return { safeIbCommentText, safeIbCommentMetadataText };
+  } catch (error) {
+    console.error(`${lc} ${error.message}`);
+    throw error;
+  } finally {
+    if (logalot) { console.log(`${lc} complete.`); }
+  }
+}
+
+/**
+ * creates a comment ibgib, returning the transform result,
+ * optionally saving it in a given {@link space}.
+ */
+export async function createCommentIbGib({
+  text,
+  addlMetadataText,
+  saveInSpace,
+  space,
+}: {
+  /**
+   * comment text
+   */
+  text: string,
+  /**
+   * Optional metadata string to be included in the comment's ib.
+   * Should be underscore-delimited but not a hard rule atow.
+   *
+   * @example "comment thisisacomm here_is_addl_metadata"
+   */
+  addlMetadataText?: string;
+  /**
+   * If true, will save the ibgibs created in the given {@link space}.
+   */
+  saveInSpace?: boolean,
+  /**
+   * If {@link saveInSpace}, all ibgibs created in this function will be stored in
+   * this space.
+   */
+  space?: IbGibSpaceAny,
+}): Promise<TransformResult<CommentIbGib_V1>> {
+  const lc = `[${createCommentIbGib.name}]`;
+
+  if (logalot) { console.log(`${lc} starting...`); }
+  try {
+    if (!text) { throw new Error(`text required (E: 3e3d0f555e1a83771a6548eb10943522)`); }
+
+    text = text.trim();
+
+    if (!text) { throw new Error(`text cannot be only whitespace (E: d6db3537b9834294836aeb70987c908e)`); }
+
+    const data: CommentData_V1 = { text, textTimestamp: getTimestamp() };
+
+    // create an ibgib with the filename and ext
+    const opts: any = {
+      parentIbGib: factory.primitive({ ib: 'comment' }),
+      ib: getCommentIb({ commentText: text, addlMetadataText }),
+      data,
+      dna: true,
+      tjp: { uuid: true, timestamp: true },
+      nCounter: true,
+    };
+
+    // this makes it more difficult to share/sync ibgibs...
+    // if (this.addr) { opts.rel8ns = { 'comment on': [this.addr] }; }
+
+    if (logalot) { console.log(`${lc} opts: ${pretty(opts)}`); }
+    const resCommentIbGib = await factory.firstGen(opts) as TransformResult<CommentIbGib_V1>;
+
+    if (saveInSpace) {
+      if (!space) { throw new Error(`space required if saveInSpace is truthy (E: 40f69f22f21b4279a83cb746cb4b0da1)`); }
+      await persistTransformResult({ resTransform: resCommentIbGib, space });
+    }
+
+    return resCommentIbGib;
+  } catch (error) {
+    console.error(`${lc} ${error.message}`);
+    throw error;
+  }
+}
+
+export function isComment({
+  ibGib,
+}: {
+  ibGib: IbGib_V1,
+}): boolean {
+  const lc = `[${isComment.name}]`;
+  try {
+    if (logalot) { console.log(`${lc} starting...`); }
+
+    if (!ibGib) { throw new Error(`ibGib required (E: f204dac30ae548b0a049f1c4d8048502)`); }
+
+    const { ib, data, rel8ns } = ibGib;
+
+    // try rel8ns first
+    if (!rel8ns) {
+      if (logalot) { console.log(`${lc} rel8ns falsy, NOT a comment (I: 6e145eb2d0ba46629746215a3b655fd5)`); }
+      return false;
+    }
+
+    // descends from comment^gib
+    const ancestors = rel8ns.ancestor || [];
+    if (ancestors && ancestors.includes('comment^gib')) {
+      if (logalot) { console.log(`${lc} descends from comment^gib, YES is a comment (I: 1a8557780e2e4c1580d5a2585567762b)`); }
+      return true;
+    }
+
+    // has binary qualities and ib contains 'comment'
+    if (!data) {
+      if (logalot) { console.log(`${lc} data falsy, NOT a comment (I: 30b20ff6785f432f98489f11efe24299)`); }
+      return false;
+    }
+    if (data.text && ib?.includes('comment')) {
+      if (logalot) { console.log(`${lc} has text, and ib has 'comment', YES is a comment (I: 3aa03bcd639d4ec7abd7ead917eda3d8)`); }
+      return true;
+    }
+
+    if (logalot) { console.log(`${lc} reached end, doesn't have comment qualities. NOT a comment. (I: cfa529f27f9d490abd476c924ef77087)`); }
+    return false;
+  } catch (error) {
+    console.error(`${lc} ${error.message}`);
+    throw error;
+  } finally {
+    if (logalot) { console.log(`${lc} complete.`); }
+  }
+}

package/src/common/comment/comment-types.mts

@@ -0,0 +1,19 @@
+import { TransformResult } from '@ibgib/ts-gib';
+import { IbGibData_V1, IbGibRel8ns_V1, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/index.mjs';
+
+/**
+ * Data for a comment ibGib
+ */
+export interface CommentData_V1 extends IbGibData_V1 {
+    text: string;
+    textTimestamp?: string;
+    timestamp?: string;
+}
+
+export interface CommentRel8ns_V1 extends IbGibRel8ns_V1 {
+}
+
+export interface CommentIbGib_V1 extends IbGib_V1<CommentData_V1, CommentRel8ns_V1> {
+}
+
+export type UpdateCommentPromptResult = TransformResult<CommentIbGib_V1>;

package/src/common/display/display-helper.mts

@@ -0,0 +1,88 @@
+import { Ib, } from '@ibgib/ts-gib';
+
+import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
+import {
+    DisplayData_V1, DisplayRel8ns_V1, DisplayIbGib_V1,
+    DISPLAY_ATOM,
+    // DisplayOutputMode, VALID_DISPLAY_OUTPUT_MODES
+} from './display-types.mjs';
+
+
+const logalot = GLOBAL_LOG_A_LOT || false;
+
+
+export function validateDisplayData({
+    data,
+}: {
+    data: DisplayData_V1,
+}): string[] {
+    const lc = `[${validateDisplayData.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting...`); }
+        if (!data) { throw new Error(`displayData required (E: 9e138d1bc84c4dbdaad768e85ce3dfa7)`); }
+        const errors: string[] = [];
+        const {
+            uuid,
+            filters,
+            sorts,
+        } =
+            data;
+
+        if (logalot) { console.warn(`${lc} not implemented yet (W: cc8c2d55cdbb40bc85531d8ff4df5bbc)`); }
+
+        if (filters?.length ?? 0 > 0) { }
+
+        if (sorts?.length ?? 0 > 0) { }
+
+        return errors;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}
+
+export function getDisplayIb({
+    data,
+}: {
+    data: DisplayData_V1,
+}): Ib {
+    const lc = `[${getDisplayIb.name}]`;
+    try {
+        const validationErrors = validateDisplayData({ data });
+        if (validationErrors.length > 0) { throw new Error(`invalid data: ${validationErrors} (E: 8b025bed03b7477e8114fb0f3fc68aea)`); }
+
+        const { ticks } = data;
+
+        return `${DISPLAY_ATOM} ${ticks}`
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}
+
+/**
+ * Current schema is `witness display [classname] [displayName] [displayId]
+ *
+ * NOTE this is space-delimited
+ */
+export function parseDisplayIb({
+    displayIb,
+}: {
+    displayIb: Ib,
+}): {
+    ticks: string,
+} {
+    const lc = `[${parseDisplayIb.name}]`;
+    try {
+        if (!displayIb) { throw new Error(`displayIb required (E: d9920ab1683042388d156b1ae781565d)`); }
+
+        const [atom, ticks] = displayIb.split(' ');
+
+        return { ticks, };
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}

package/src/common/display/display-types.mts

@@ -0,0 +1,108 @@
+import { IbGibData_V1, IbGibRel8ns_V1, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/index.mjs';
+
+export type SortStrategy = 'data_path';
+export const SortStrategy = {
+    /**
+     * sorts targeting a specific path in the ibgib.data object.
+     *
+     * So if you want to sort by comment text, then the path will
+     * be `'text'`. If you want to sort by date, then `'timestamp'`.
+     */
+    data_path: "data_path" as SortStrategy,
+}
+
+export type SortDirection = 'ascending' | 'descending' | 'forward' | 'reverse';
+export const SortDirection =
+{
+    /**
+     * In an ordered list, we will sort starting with the least and going to the
+     * greatest.
+     */
+    ascending: 'ascending' as SortDirection,
+    /**
+     * In an ordered list, we will sort starting with the highest/greatest and
+     * go to the lowest/least.
+     */
+    descending: 'descending' as SortDirection,
+    /**
+     * Often the same as ascending, but depends on context.
+     *
+     * For example, there may be a non-ascending existing order and we are
+     * speaking relative to this.
+     */
+    forward: 'forward' as SortDirection,
+    /**
+     * Often the same as descending, but depends on context.
+     *
+     * For example, there may be a non-ordered existing list and we are speaking
+     * relative to this.
+     */
+    reverse: 'reverse' as SortDirection,
+}
+export type FilterType = 'keyword' | 'time';
+
+export interface FilterInfo {
+    filterType: FilterType;
+    /**
+     * if provided, uses custom data path(s) into the ibgib.data object to
+     * filter against.
+     *
+     * If not provided, this defaults to whatever makes sense for the ibgib. For
+     * example, a comment or link ibgib will default to the 'text' path. A pic
+     * will look in filename, extension, and maybe some others that I haven't
+     * implemented yet.
+     */
+    dataPaths?: string[];
+
+    /**
+     * self explanatory
+     */
+    caseSensitive?: boolean;
+    hasAllKeywords?: string[];
+    hasNoneKeywords?: string[];
+    hasAnyKeywords?: string[];
+
+    /**
+     * If filterType is 'time', then this is the earliest date/time.
+     * If it's 'keyword', then this is lower bound by character. (may not implement at first)
+     */
+    startBound?: string;
+    endBound?: string;
+    startBoundInclusive?: boolean;
+    endBoundInclusive?: boolean;
+}
+
+export interface SortInfo {
+    /**
+     * How we're approaching the sort.
+     *
+     * ATOW this is just 'data_path'
+     */
+    strategy: SortStrategy;
+    /**
+     * If supplied, then this will dictate how the sort ordered.
+     */
+    direction?: SortDirection;
+    /**
+     * If the `strategy` is 'data_path', then this is the value of
+     * the data_path.
+     *
+     * @example 'text' if sorting by comment text
+     */
+    value: string;
+}
+
+export interface DisplayData_V1 extends IbGibData_V1 {
+    ticks: string;
+    filters?: FilterInfo[];
+    sorts?: SortInfo[];
+}
+export interface DisplayRel8ns_V1 extends IbGibRel8ns_V1 {
+
+}
+
+export interface DisplayIbGib_V1 extends IbGib_V1<DisplayData_V1, DisplayRel8ns_V1> {
+
+}
+
+export const DISPLAY_ATOM = 'display';

package/src/common/encrypt/encrypt-constants.mts

@@ -0,0 +1,28 @@
+import { SaltStrategy } from '@ibgib/encrypt-gib/dist/index.mjs';
+
+export const DEFAULT_ENCRYPTION_INITIAL_RECURSIONS = 50000;
+export const MIN_ENCRYPTION_INITIAL_RECURSIONS = 1000;
+export const MAX_ENCRYPTION_INITIAL_RECURSIONS = 10000000;
+export const MIN_ENCRYPTION_RECURSIONS_PER_HASH = 1;
+export const MAX_ENCRYPTION_RECURSIONS_PER_HASH = 1000;
+export const MIN_ENCRYPTION_SALT_LENGTH = 50;
+export const MAX_ENCRYPTION_SALT_LENGTH = 99999;
+export const MIN_ENCRYPTION_PASSWORD_LENGTH = 8;
+export const MAX_ENCRYPTION_PASSWORD_LENGTH = 9999999;
+export const DEFAULT_ENCRYPTION_SALT_STRATEGY: SaltStrategy = SaltStrategy.appendPerHash;
+export const DEFAULT_ENCRYPTION_RECURSIONS_PER_HASH = 10;
+export const DEFAULT_ENCRYPTION_HASH_ALGORITHM = 'SHA-256';
+
+/**
+ * A secrets ibgib uses this rel8n name for its children secrets.
+ */
+export const SECRET_REL8N_NAME = 'secret';
+/**
+ * An encryptions ibgib uses this rel8n name for its children encryptions.
+ */
+export const ENCRYPTION_REL8N_NAME = 'encryption';
+/**
+ * Related encrypted ciphertext ibgibs will use this rel8n name.
+ * Those ciphertext ibgibs will then relate to the encryption used.
+ */
+export const CIPHERTEXT_REL8N_NAME = 'ciphertext';