@solana/instruction-plans 0.0.0 → 3.0.0-canary-20250718212840

package/dist/types/instruction-plan.d.ts

@@ -0,0 +1,394 @@
+import { Instruction } from '@solana/instructions';
+import { BaseTransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';
+/**
+ * A set of instructions with constraints on how they can be executed.
+ *
+ * This is structured as a recursive tree of plans in order to allow for
+ * parallel execution, sequential execution and combinations of both.
+ *
+ * Namely the following plans are supported:
+ * - {@link SingleInstructionPlan} - A plan that contains a single instruction.
+ *   This is a simple instruction wrapper and the simplest leaf in this tree.
+ * - {@link ParallelInstructionPlan} - A plan that contains other plans that
+ *   can be executed in parallel.
+ * - {@link SequentialInstructionPlan} - A plan that contains other plans that
+ *   must be executed sequentially. It also defines whether the plan is divisible
+ *   meaning that instructions inside it can be split into separate transactions.
+ * - {@link MessagePackerInstructionPlan} - A plan that can dynamically pack
+ *  instructions into transaction messages.
+ *
+ * Helpers are provided for each of these plans to make it easier to create them.
+ *
+ * @example
+ * ```ts
+ * const myInstructionPlan: InstructionPlan = parallelInstructionPlan([
+ *    sequentialInstructionPlan([instructionA, instructionB]),
+ *    instructionC,
+ *    instructionD,
+ * ]);
+ * ```
+ *
+ * @see {@link SingleInstructionPlan}
+ * @see {@link ParallelInstructionPlan}
+ * @see {@link SequentialInstructionPlan}
+ * @see {@link MessagePackerInstructionPlan}
+ */
+export type InstructionPlan = MessagePackerInstructionPlan | ParallelInstructionPlan | SequentialInstructionPlan | SingleInstructionPlan;
+/**
+ * A plan wrapping other plans that must be executed sequentially.
+ *
+ * It also defines whether nested plans are divisible — meaning that
+ * the instructions inside them can be split into separate transactions.
+ * When `divisible` is `false`, the instructions inside the plan should
+ * all be executed atomicly — either in a single transaction or in a
+ * transaction bundle.
+ *
+ * You may use the {@link sequentialInstructionPlan} and {@link nonDivisibleSequentialInstructionPlan}
+ * helpers to create objects of this type.
+ *
+ * @example Simple sequential plan with two instructions.
+ * ```ts
+ * const plan = sequentialInstructionPlan([instructionA, instructionB]);
+ * plan satisfies SequentialInstructionPlan;
+ * ```
+ *
+ * @example Non-divisible sequential plan with two instructions.
+ * ```ts
+ * const plan = nonDivisibleSequentialInstructionPlan([instructionA, instructionB]);
+ * plan satisfies SequentialInstructionPlan & { divisible: false };
+ * ```
+ *
+ * @example Sequential plan with nested parallel plans.
+ * Here, instructions A and B can be executed in parallel, but they must both be finalized
+ * before instructions C and D can be sent — which can also be executed in parallel.
+ * ```ts
+ * const plan = sequentialInstructionPlan([
+ *   parallelInstructionPlan([instructionA, instructionB]),
+ *   parallelInstructionPlan([instructionC, instructionD]),
+ * ]);
+ * plan satisfies SequentialInstructionPlan & { divisible: false };
+ * ```
+ *
+ * @see {@link sequentialInstructionPlan}
+ * @see {@link nonDivisibleSequentialInstructionPlan}
+ */
+export type SequentialInstructionPlan = Readonly<{
+    divisible: boolean;
+    kind: 'sequential';
+    plans: InstructionPlan[];
+}>;
+/**
+ * A plan wrapping other plans that can be executed in parallel.
+ *
+ * This means direct children of this plan can be executed in separate
+ * parallel transactions without consequence.
+ * However, the children themselves can define additional constraints
+ * for that specific branch of the tree — such as the {@link SequentialInstructionPlan}.
+ *
+ * You may use the {@link parallelInstructionPlan} helper to create objects of this type.
+ *
+ * @example Simple parallel plan with two instructions.
+ * ```ts
+ * const plan = parallelInstructionPlan([instructionA, instructionB]);
+ * plan satisfies ParallelInstructionPlan;
+ * ```
+ *
+ * @example Parallel plan with nested sequential plans.
+ * Here, instructions A and B must be executed sequentially and so must instructions C and D,
+ * but both pairs can be executed in parallel.
+ * ```ts
+ * const plan = parallelInstructionPlan([
+ *   sequentialInstructionPlan([instructionA, instructionB]),
+ *   sequentialInstructionPlan([instructionC, instructionD]),
+ * ]);
+ * plan satisfies ParallelInstructionPlan;
+ * ```
+ *
+ * @see {@link parallelInstructionPlan}
+ */
+export type ParallelInstructionPlan = Readonly<{
+    kind: 'parallel';
+    plans: InstructionPlan[];
+}>;
+/**
+ * A plan that contains a single instruction.
+ *
+ * This is a simple instruction wrapper that transforms an instruction into a plan.
+ *
+ * You may use the {@link singleInstructionPlan} helper to create objects of this type.
+ *
+ * @example
+ * ```ts
+ * const plan = singleInstructionPlan(instructionA);
+ * plan satisfies SingleInstructionPlan;
+ * ```
+ *
+ * @see {@link singleInstructionPlan}
+ */
+export type SingleInstructionPlan<TInstruction extends Instruction = Instruction> = Readonly<{
+    instruction: TInstruction;
+    kind: 'single';
+}>;
+/**
+ * A plan that can dynamically pack instructions into transaction messages.
+ *
+ * This plan provides a {@link MessagePacker} via the `getMessagePacker`
+ * method, which enables instructions to be dynamically packed into the
+ * provided transaction message until there are no more instructions to pack.
+ * The returned {@link MessagePacker} offers a `packMessageToCapacity(message)`
+ * method that packs the provided message — when possible — and a `done()` method
+ * that checks whether there are more instructions to pack.
+ *
+ * Several helper functions are provided to create objects of this type such as
+ * {@link getLinearMessagePackerInstructionPlan} or {@link getMessagePackerInstructionPlanFromInstructions}.
+ *
+ * @example An message packer plan for a write instruction that uses as many bytes as possible.
+ * ```ts
+ * const plan = getLinearMessagePackerInstructionPlan({
+ *   totalLength: dataToWrite.length,
+ *   getInstruction: (offset, length) =>
+ *     getWriteInstruction({
+ *       offset,
+ *       data: dataToWrite.slice(offset, offset + length),
+ *     }),
+ * });
+ * plan satisfies MessagePackerInstructionPlan;
+ * ```
+ *
+ * @example A message packer plan for multiple realloc instructions.
+ * ```ts
+ * const plan = getReallocMessagePackerInstructionPlan({
+ *   totalSize: additionalDataSize,
+ *   getInstruction: (size) => getExtendInstruction({ length: size }),
+ * });
+ * plan satisfies MessagePackerInstructionPlan;
+ * ```
+ *
+ * @example Using a message packer plan.
+ * ```ts
+ * let plan: MessagePackerInstructionPlan;
+ * const messagePacker = plan.getMessagePacker();
+ *
+ * while (!messagePacker.done()) {
+ *   try {
+ *     transactionMessage = messagePacker.packMessageToCapacity(transactionMessage);
+ *   } catch (error) {
+ *     // The current transaction message cannot be used to pack this plan.
+ *     // We should create a new one and try again.
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link getLinearMessagePackerInstructionPlan}
+ * @see {@link getMessagePackerInstructionPlanFromInstructions}
+ * @see {@link getReallocMessagePackerInstructionPlan}
+ */
+export type MessagePackerInstructionPlan = Readonly<{
+    getMessagePacker: () => MessagePacker;
+    kind: 'messagePacker';
+}>;
+/**
+ * The message packer returned by the {@link MessagePackerInstructionPlan}.
+ *
+ * It offers a `packMessageToCapacity(transactionMessage)` method that packs as many instructions
+ * as possible into the provided transaction message, while still being able to fit into the
+ * transaction size limit. It returns the updated transaction message with the packed instructions
+ * or throws an error if the current transaction message cannot accommodate this plan.
+ *
+ * The `done()` method checks whether there are more instructions to pack into
+ * transaction messages.
+ *
+ * @example
+ * ```ts
+ * let plan: MessagePackerInstructionPlan;
+ * const messagePacker = plan.getMessagePacker();
+ *
+ * while (!messagePacker.done()) {
+ *   try {
+ *     transactionMessage = messagePacker.packMessageToCapacity(transactionMessage);
+ *   } catch (error) {
+ *     // The current transaction message cannot be used to pack this plan.
+ *     // We should create a new one and try again.
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link MessagePackerInstructionPlan}
+ */
+export type MessagePacker = Readonly<{
+    /** Checks whether the message packer has more instructions to pack into transaction messages. */
+    done: () => boolean;
+    /**
+     * Packs the provided transaction message with instructions or throws if not possible.
+     *
+     * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN}
+     *   if the provided transaction message cannot be used to fill the next instructions.
+     * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE}
+     *   if the message packer is already done and no more instructions can be packed.
+     */
+    packMessageToCapacity: (transactionMessage: BaseTransactionMessage & TransactionMessageWithFeePayer) => BaseTransactionMessage & TransactionMessageWithFeePayer;
+}>;
+/**
+ * Creates a {@link ParallelInstructionPlan} from an array of nested plans.
+ *
+ * It can accept {@link Instruction} objects directly, which will be wrapped
+ * in {@link SingleInstructionPlan | SingleInstructionPlans} automatically.
+ *
+ * @example Using explicit {@link SingleInstructionPlan | SingleInstructionPlans}.
+ * ```ts
+ * const plan = parallelInstructionPlan([
+ *   singleInstructionPlan(instructionA),
+ *   singleInstructionPlan(instructionB),
+ * ]);
+ * ```
+ *
+ * @example Using {@link Instruction | Instructions} directly.
+ * ```ts
+ * const plan = parallelInstructionPlan([instructionA, instructionB]);
+ * ```
+ *
+ * @see {@link ParallelInstructionPlan}
+ */
+export declare function parallelInstructionPlan(plans: (Instruction | InstructionPlan)[]): ParallelInstructionPlan;
+/**
+ * Creates a divisible {@link SequentialInstructionPlan} from an array of nested plans.
+ *
+ * It can accept {@link Instruction} objects directly, which will be wrapped
+ * in {@link SingleInstructionPlan | SingleInstructionPlans} automatically.
+ *
+ * @example Using explicit {@link SingleInstructionPlan | SingleInstructionPlans}.
+ * ```ts
+ * const plan = sequentialInstructionPlan([
+ *   singleInstructionPlan(instructionA),
+ *   singleInstructionPlan(instructionB),
+ * ]);
+ * ```
+ *
+ * @example Using {@link Instruction | Instructions} directly.
+ * ```ts
+ * const plan = sequentialInstructionPlan([instructionA, instructionB]);
+ * ```
+ *
+ * @see {@link SequentialInstructionPlan}
+ */
+export declare function sequentialInstructionPlan(plans: (Instruction | InstructionPlan)[]): SequentialInstructionPlan & {
+    divisible: true;
+};
+/**
+ * Creates a non-divisible {@link SequentialInstructionPlan} from an array of nested plans.
+ *
+ * It can accept {@link Instruction} objects directly, which will be wrapped
+ * in {@link SingleInstructionPlan | SingleInstructionPlans} automatically.
+ *
+ * @example Using explicit {@link SingleInstructionPlan | SingleInstructionPlans}.
+ * ```ts
+ * const plan = nonDivisibleSequentialInstructionPlan([
+ *   singleInstructionPlan(instructionA),
+ *   singleInstructionPlan(instructionB),
+ * ]);
+ * ```
+ *
+ * @example Using {@link Instruction | Instructions} directly.
+ * ```ts
+ * const plan = nonDivisibleSequentialInstructionPlan([instructionA, instructionB]);
+ * ```
+ *
+ * @see {@link SequentialInstructionPlan}
+ */
+export declare function nonDivisibleSequentialInstructionPlan(plans: (Instruction | InstructionPlan)[]): SequentialInstructionPlan & {
+    divisible: false;
+};
+/**
+ * Creates a {@link SingleInstructionPlan} from an {@link Instruction} object.
+ *
+ * @example
+ * ```ts
+ * const plan = singleInstructionPlan(instructionA);
+ * ```
+ *
+ * @see {@link SingleInstructionPlan}
+ */
+export declare function singleInstructionPlan(instruction: Instruction): SingleInstructionPlan;
+/**
+ * Creates a {@link MessagePackerInstructionPlan} that packs instructions
+ * such that each instruction consumes as many bytes as possible from the given
+ * `totalLength` while still being able to fit into the given transaction messages.
+ *
+ * This is particularly useful for instructions that write data to accounts and must
+ * span multiple transactions due to their size limit.
+ *
+ * This message packer will first call `getInstruction` with a length of zero to
+ * determine the base size of the instruction before figuring out how many
+ * additional bytes can be packed into the transaction message. That remaining space
+ * will then be used to call `getInstruction` again with the appropriate length.
+ *
+ * @param getInstruction - A function that returns an instruction for a given offset and length.
+ * @param totalLength - The total length of the data to write, in bytes.
+ *
+ * @example
+ * ```ts
+ * const plan = getLinearMessagePackerInstructionPlan({
+ *   totalLength: dataToWrite.length,
+ *   getInstruction: (offset, length) =>
+ *     getWriteInstruction({
+ *       offset,
+ *       data: dataToWrite.slice(offset, offset + length),
+ *     }),
+ * });
+ * plan satisfies MessagePackerInstructionPlan;
+ * ```
+ *
+ * @see {@link MessagePackerInstructionPlan}
+ */
+export declare function getLinearMessagePackerInstructionPlan({ getInstruction, totalLength: totalBytes, }: {
+    getInstruction: (offset: number, length: number) => Instruction;
+    totalLength: number;
+}): MessagePackerInstructionPlan;
+/**
+ * Creates a {@link MessagePackerInstructionPlan} from a list of instructions.
+ *
+ * This can be useful to prepare a set of instructions that can be iterated over
+ * — e.g. to pack a list of instructions that gradually reallocate the size of an account
+ * one `REALLOC_LIMIT` (10'240 bytes) at a time.
+ *
+ * @example
+ * ```ts
+ * const plan = getMessagePackerInstructionPlanFromInstructions([
+ *   instructionA,
+ *   instructionB,
+ *   instructionC,
+ * ]);
+ *
+ * const messagePacker = plan.getMessagePacker();
+ * firstTransactionMessage = messagePacker.packMessageToCapacity(firstTransactionMessage);
+ * // Contains instruction A and instruction B.
+ * secondTransactionMessage = messagePacker.packMessageToCapacity(secondTransactionMessage);
+ * // Contains instruction C.
+ * messagePacker.done(); // true
+ * ```
+ *
+ * @see {@link MessagePackerInstructionPlan}
+ * @see {@link getReallocMessagePackerInstructionPlan}
+ */
+export declare function getMessagePackerInstructionPlanFromInstructions<TInstruction extends Instruction = Instruction>(instructions: TInstruction[]): MessagePackerInstructionPlan;
+/**
+ * Creates a {@link MessagePackerInstructionPlan} that packs a list of realloc instructions.
+ *
+ * That is, it splits instruction by chunks of `REALLOC_LIMIT` (10'240) bytes until
+ * the given total size is reached.
+ *
+ * @example
+ * ```ts
+ * const plan = getReallocMessagePackerInstructionPlan({
+ *   totalSize: additionalDataSize,
+ *   getInstruction: (size) => getExtendInstruction({ length: size }),
+ * });
+ * ```
+ *
+ * @see {@link MessagePackerInstructionPlan}
+ */
+export declare function getReallocMessagePackerInstructionPlan({ getInstruction, totalSize, }: {
+    getInstruction: (size: number) => Instruction;
+    totalSize: number;
+}): MessagePackerInstructionPlan;
+//# sourceMappingURL=instruction-plan.d.ts.map

package/dist/types/instruction-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-plan.d.ts","sourceRoot":"","sources":["../../src/instruction-plan.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,11 +1,86 @@
 {
   "name": "@solana/instruction-plans",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "3.0.0-canary-20250718212840",
+  "description": "Construct, plan and execute transactions from multiple instructions.",
+  "exports": {
+    "edge-light": {
+      "import": "./dist/index.node.mjs",
+      "require": "./dist/index.node.cjs"
+    },
+    "workerd": {
+      "import": "./dist/index.node.mjs",
+      "require": "./dist/index.node.cjs"
+    },
+    "browser": {
+      "import": "./dist/index.browser.mjs",
+      "require": "./dist/index.browser.cjs"
+    },
+    "node": {
+      "import": "./dist/index.node.mjs",
+      "require": "./dist/index.node.cjs"
+    },
+    "react-native": "./dist/index.native.mjs",
+    "types": "./dist/types/index.d.ts"
+  },
+  "browser": {
+    "./dist/index.node.cjs": "./dist/index.browser.cjs",
+    "./dist/index.node.mjs": "./dist/index.browser.mjs"
+  },
+  "main": "./dist/index.node.cjs",
+  "module": "./dist/index.node.mjs",
+  "react-native": "./dist/index.native.mjs",
+  "types": "./dist/types/index.d.ts",
+  "type": "commonjs",
+  "files": [
+    "./dist/"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "blockchain",
+    "solana",
+    "web3"
+  ],
+  "author": "Solana Labs Maintainers <maintainers@solanalabs.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anza-xyz/kit"
+  },
+  "bugs": {
+    "url": "https://github.com/anza-xyz/kit/issues"
   },
-  "author": "",
-  "license": "ISC"
-}
+  "browserslist": [
+    "supports bigint and not dead",
+    "maintained node versions"
+  ],
+  "dependencies": {
+    "@solana/errors": "3.0.0-canary-20250718212840",
+    "@solana/promises": "3.0.0-canary-20250718212840",
+    "@solana/instructions": "3.0.0-canary-20250718212840",
+    "@solana/transactions": "3.0.0-canary-20250718212840",
+    "@solana/transaction-messages": "3.0.0-canary-20250718212840"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.3.3"
+  },
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "scripts": {
+    "compile:docs": "typedoc",
+    "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json",
+    "dev": "jest -c ../../node_modules/@solana/test-config/jest-dev.config.ts --rootDir . --watch",
+    "publish-impl": "npm view $npm_package_name@$npm_package_version > /dev/null 2>&1 || (pnpm publish --tag ${PUBLISH_TAG:-canary} --access public --no-git-checks && (([ \"$PUBLISH_TAG\" != \"canary\" ] && pnpm dist-tag add $npm_package_name@$npm_package_version latest) || true))",
+    "publish-packages": "pnpm prepublishOnly && pnpm publish-impl",
+    "style:fix": "pnpm eslint --fix src && pnpm prettier --log-level warn --ignore-unknown --write ./*",
+    "test:lint": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-lint.config.ts --rootDir . --silent",
+    "test:prettier": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-prettier.config.ts --rootDir . --silent",
+    "test:treeshakability:browser": "agadoo dist/index.browser.mjs",
+    "test:treeshakability:native": "agadoo dist/index.native.mjs",
+    "test:treeshakability:node": "agadoo dist/index.node.mjs",
+    "test:typecheck": "tsc --noEmit",
+    "test:unit:browser": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-unit.config.browser.ts --rootDir . --silent",
+    "test:unit:node": "TERM_OVERRIDE=\"${TURBO_HASH:+dumb}\" TERM=${TERM_OVERRIDE:-$TERM} jest -c ../../node_modules/@solana/test-config/jest-unit.config.node.ts --rootDir . --silent"
+  }
+}

package/.bash_logout

@@ -1,7 +0,0 @@
-# ~/.bash_logout: executed by bash(1) when login shell exits.
-
-# when leaving the console clear the screen to increase privacy
-
-if [ "$SHLVL" = 1 ]; then
-    [ -x /usr/bin/clear_console ] && /usr/bin/clear_console -q
-fi

package/.bashrc

@@ -1,113 +0,0 @@
-# ~/.bashrc: executed by bash(1) for non-login shells.
-# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
-# for examples
-
-# If not running interactively, don't do anything
-case $- in
-    *i*) ;;
-      *) return;;
-esac
-
-# don't put duplicate lines or lines starting with space in the history.
-# See bash(1) for more options
-HISTCONTROL=ignoreboth
-
-# append to the history file, don't overwrite it
-shopt -s histappend
-
-# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
-HISTSIZE=1000
-HISTFILESIZE=2000
-
-# check the window size after each command and, if necessary,
-# update the values of LINES and COLUMNS.
-shopt -s checkwinsize
-
-# If set, the pattern "**" used in a pathname expansion context will
-# match all files and zero or more directories and subdirectories.
-#shopt -s globstar
-
-# make less more friendly for non-text input files, see lesspipe(1)
-#[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"
-
-# set variable identifying the chroot you work in (used in the prompt below)
-if [ -z "${debian_chroot:-}" ] && [ -r /etc/debian_chroot ]; then
-    debian_chroot=$(cat /etc/debian_chroot)
-fi
-
-# set a fancy prompt (non-color, unless we know we "want" color)
-case "$TERM" in
-    xterm-color|*-256color) color_prompt=yes;;
-esac
-
-# uncomment for a colored prompt, if the terminal has the capability; turned
-# off by default to not distract the user: the focus in a terminal window
-# should be on the output of commands, not on the prompt
-#force_color_prompt=yes
-
-if [ -n "$force_color_prompt" ]; then
-    if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
-	# We have color support; assume it's compliant with Ecma-48
-	# (ISO/IEC-6429). (Lack of such support is extremely rare, and such
-	# a case would tend to support setf rather than setaf.)
-	color_prompt=yes
-    else
-	color_prompt=
-    fi
-fi
-
-if [ "$color_prompt" = yes ]; then
-    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
-else
-    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
-fi
-unset color_prompt force_color_prompt
-
-# If this is an xterm set the title to user@host:dir
-case "$TERM" in
-xterm*|rxvt*)
-    PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
-    ;;
-*)
-    ;;
-esac
-
-# enable color support of ls and also add handy aliases
-if [ -x /usr/bin/dircolors ]; then
-    test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
-    alias ls='ls --color=auto'
-    #alias dir='dir --color=auto'
-    #alias vdir='vdir --color=auto'
-
-    #alias grep='grep --color=auto'
-    #alias fgrep='fgrep --color=auto'
-    #alias egrep='egrep --color=auto'
-fi
-
-# colored GCC warnings and errors
-#export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01'
-
-# some more ls aliases
-#alias ll='ls -l'
-#alias la='ls -A'
-#alias l='ls -CF'
-
-# Alias definitions.
-# You may want to put all your additions into a separate file like
-# ~/.bash_aliases, instead of adding them here directly.
-# See /usr/share/doc/bash-doc/examples in the bash-doc package.
-
-if [ -f ~/.bash_aliases ]; then
-    . ~/.bash_aliases
-fi
-
-# enable programmable completion features (you don't need to enable
-# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
-# sources /etc/bash.bashrc).
-if ! shopt -oq posix; then
-  if [ -f /usr/share/bash-completion/bash_completion ]; then
-    . /usr/share/bash-completion/bash_completion
-  elif [ -f /etc/bash_completion ]; then
-    . /etc/bash_completion
-  fi
-fi

package/.npm/_cacache/index-v5/a6/aa/29e44d5a310c9b93c5aa5fba31edf53f53cfa917687cfe0458292b3a2017

@@ -1,3 +0,0 @@
-
-3d8a1521c0ac537da42611d55e42cb96f9d78495	{"key":"pacote:tarball:file:/home/jacob_creech","integrity":"sha512-kFX9Q6wT6aBNHnUvK6shbG5+Ufae001AcpA+5l8qHS+zQ3rQagLOk/RB4skdis0A4M/h0MOsb28NCsFDqJsnHw==","time":1752789773163,"size":3571}
-28dd201d2d1e608c0dfa1a82cedbb508a0ed702b	{"key":"pacote:tarball:file:/home/jacob_creech","integrity":"sha512-CrIePuXfDwzK3uRu2h60xhNq6XrvFMk53otVh8HrQYSnxKvNf6Llkc6Ei+Vqh5pgUELIQJMDCuGeyFvb1iY2CQ==","time":1752789856056,"size":9293}

package/.npm/_logs/2025-07-17T21_52_29_821Z-debug-0.log

@@ -1,33 +0,0 @@
-0 verbose cli /usr/bin/node /usr/bin/npm
-1 info using npm@9.2.0
-2 info using node@v18.19.0
-3 timing npm:load:whichnode Completed in 0ms
-4 timing config:load:defaults Completed in 2ms
-5 timing config:load:file:/usr/share/nodejs/npm/npmrc Completed in 3ms
-6 timing config:load:builtin Completed in 3ms
-7 timing config:load:cli Completed in 2ms
-8 timing config:load:env Completed in 0ms
-9 timing config:load:project Completed in 1ms
-10 timing config:load:file:/home/jacob_creech/.npmrc Completed in 1ms
-11 timing config:load:user Completed in 1ms
-12 timing config:load:file:/etc/npmrc Completed in 0ms
-13 timing config:load:global Completed in 0ms
-14 timing config:load:setEnvs Completed in 1ms
-15 timing config:load Completed in 10ms
-16 timing npm:load:configload Completed in 10ms
-17 timing npm:load:mkdirpcache Completed in 1ms
-18 timing npm:load:mkdirplogs Completed in 0ms
-19 verbose title npm
-20 verbose argv "--version"
-21 timing npm:load:setTitle Completed in 2ms
-22 timing config:load:flatten Completed in 3ms
-23 timing npm:load:display Completed in 4ms
-24 verbose logfile logs-max:10 dir:/home/jacob_creech/.npm/_logs/2025-07-17T21_52_29_821Z-
-25 verbose logfile /home/jacob_creech/.npm/_logs/2025-07-17T21_52_29_821Z-debug-0.log
-26 timing npm:load:logFile Completed in 5ms
-27 timing npm:load:timers Completed in 0ms
-28 timing npm:load:configScope Completed in 0ms
-29 timing npm:load Completed in 23ms
-30 verbose exit 0
-31 timing npm Completed in 31ms
-32 info ok