Link Loom SDK

The Runtime Orchestrator for Node.js Ecosystems.

Link Loom SDK is a runtime foundation designed to standardize application initialization, dependency resolution, and operational lifecycle. It provides a deterministic execution environment where modules, services, and adapters coexist under a strict architectural contract.

This is not merely a web framework. Link Loom operates as the Application Backbone, enabling disjointed systems—monoliths, distributed microservices, and dedicated workers—to share a unified operational signature.

Documentation Index

Getting Started

• Installation & Quick Start
• CLI Reference
• Building Your First Service

Usage Guides

• Project Structure — Analysis of the loom-svc-js template.
• Configuration Strategies — Module provisioning and default.json schema.
• Environment Management — Local Injection vs Link Loom Cloud Vault Runtime Fetch.
• Deployment Standards — Production optimization, Containerization, and Process Management.

Architecture & Concepts

• Core Concepts — The Runtime Engine, Lifecycle State Machine, and Dependency Graph.
• The Boot Lifecycle — System Events and Initialization Sequence.
• Architectural Adapters — Enabling Event-Driven, Isolated, and Modular architectures.
• LLM Context / AI Agents — Technical definitions for AI coding assistants.

Core Modules

The Runtime Kernel.

• Dependencies (DI)
• Settings & Config
• Console & Logging
• Data Types
• Utilities

Adapter Architectures

• HTTP / REST Architecture
• Event-Driven Architecture / Bus
• Modular Serverless Functions
• Isolated Long-Run Apps

Infrastructure Abstractions

• Database
• Observability
• Storage
• Email
• Push Notifications

Technical Overview

Link Loom fundamentally shifts the focus from Request Handling to System Handling.

1. The Runtime Engine

Loom instantiates a Finite State Machine that governs the application life from BOOT to SHUTDOWN. This ensures that database connections, message brokers, and background threads are initialized in a guaranteed order before any traffic is accepted.

2. The Dependency Graph

Unlike frameworks relying on decorators or implicit module imports, Loom constructs an Explicit Dependency Graph. All system capabilities (Logger, Config, DB Driver, Event Bus) are injected into a unified Context Object (dependencies), which is passed downstream to every service and route.

3. Architectural Enablers (Adapters)

Adapters in Loom are not simple wrappers; they are architectural primitives.

• Apps Adapter: Provides Thread-based Isolation for CPU-intensive tasks, decoupling them from the main event loop.
• Events Adapter: Establishes a Pub/Sub Fabric across the system, enabling decoupled, reactive architectures.
• Functions Adapter: Implements a Serverless-like Runtime within the application for scheduled (Cron) or on-demand modular logic.

Installation

npm install --save @link-loom/sdk

Basic Usage

/* const { Loom } = require('@link-loom/sdk'); */
const loom = new Loom({ root: __dirname });

const main = async () => {
  /* The ignite() method triggers the bootstrap sequence */
  const dependencies = await loom.ignite();

  dependencies.console.info('Runtime Active');
};

main();

Contributing

1. Use ESLint + Prettier.
2. Follow Conventional Commits.
3. Include unit tests and architectural documentation.

License

Licensed under the Apache License 2.0.

Link Loom SDK — Deterministic Runtime Orchestration.