skills.rest
mavi78
mavi78COMMUNITY
Explore all skills by this author →
GitHub

shared-contracts

Define shared types, IPC channels, and constants for frontend-backend contracts.

Updated Feb 8, 2026
Search Tags:#typescript#architecture#frontend-backend#define#preload#ipc#shared-contracts
One-click install
npx skills add https://github.com/mavi78/evrak-kayit-app --skill shared-contracts-mavi78
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: shared-contracts
Source: https://github.com/mavi78/evrak-kayit-app/tree/main/.agent/skills/shared-contracts
Command: npx skills add https://github.com/mavi78/evrak-kayit-app --skill shared-contracts-mavi78

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The Shared Contracts guide provides a centralized, typed contract layer to harmonize frontend-backend communication, IPC channels, and preload bridges across modules.

Core Features & Use Cases

  • Unified type definitions for common entities and module interfaces to prevent duplication and ensure consistency.
  • IPC channel conventions and preload bridge guidelines that standardize inter-process communication and access to shared constants.
  • Module onboarding workflow with recommended folder structure, barrel exports, and type-safety checks to accelerate integration.

Quick Start

Set up a new module by adding shared types, IPC definitions, and barrel exports following these guidelines.

Frequently Asked Questions about shared-contracts

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I define shared contracts for type-safe IPC in an Electron app?▼

Define shared contracts by creating a centralized layer for common types, IPC channels, and constants to ensure type-safe inter-process communication between frontend and backend modules. This enforces strict typing rules across main, preload, and renderer components.

What is the recommended folder structure for sharing TypeScript types between frontend and backend?▼

The recommended folder structure uses centralized type definitions with barrel exports to standardize shared types and module interfaces across processes. This prevents type duplication and accelerates the onboarding workflow for new modules.

How do I standardize IPC channel conventions and preload bridge guidelines in TypeScript?▼

Standardize IPC channels and preload bridges by defining unified type definitions and conventions in a shared contracts layer. This harmonizes frontend-backend communication and standardizes access to shared constants across modules.

Do I need a shared contracts layer if my frontend and backend use different type definitions?▼

Yes, a shared contracts layer prevents duplication and ensures consistency by providing unified type definitions. It satisfies strict typing rules and cross-module exports, bridging gaps between main, preload, and renderer components.

What's the best way to enforce strict typing rules for IPC and preload utilities across modules?▼

The best way to enforce strict typing rules is to implement a centralized, typed contract layer with barrel exports for new modules. This guarantees type-safe IPC and preload utilities while standardizing cross-module exports.

Related Skills

Explore More Software Engineering Skills→
MadAppGangMadAppGang
278

core-principles

Define React 19 SPA architecture and project structure principles.

Official
Basic
gouravsingh311gouravsingh311

electron-ipc

Orchestrate Electron IPC communication between main and renderer processes.

Community
Intermediate
marcusagmmarcusagm
4

lint-and-validate

Run linting, type checking, and security audits across Node.js/TypeScript and Python projects.

Community
Intermediate
joyz0joyz0

type-safety-design

Validate TypeScript runtime data with TypeBox and Zod schemas.

Community
Advanced