> ## Documentation Index
> Fetch the complete documentation index at: https://docs.attio.com/llms.txt
> Use this file to discover all available pages before exploring further.

# App configuration file

> Register all your entry points in one place (deprecated)

<Note>
  This page documents the deprecated legacy registration file, `app.ts`. It keeps working for
  existing apps, but every new app is scaffolded with the folder-based convention under
  `src/app/` and has no `app.ts` manifest (see [App structure](../extensions/overview)). To
  convert an existing app, use the
  [folder structure migration guide](../guides/folder-structure-migration). The two conventions
  can coexist while you migrate: once `src/app/` exists, `app.ts` is optional, and if the same
  extension id is registered in both places, the folder-based definition wins.
</Note>

The `app.ts` file provides a centralized way to register all of your app's **entry points** - the various features and UI components that integrate with Attio's interface.

This file should be located directly in the root of your `src` directory (`src/app.ts` or `src/app.tsx`).

## Basic structure

Every `app.ts` file follows this structure:

```typescript theme={"system"}
import type {App} from "attio"

// Import your entry points
import {myRecordAction} from "./my-record-action"
import {myWidget} from "./my-widget"

// Export the app configuration
export const app: App = {
  record: {
    actions: [myRecordAction],
    bulkActions: [],
    widgets: [myWidget],
  },
  callRecording: {
    insight: {
      textActions: [],
    },
    summary: {
      textActions: [],
    },
    transcript: {
      textActions: [],
    },
  },
}
```

## Entry point types

The `app.ts` file organizes entry points into logical categories:

### Record entry points

These appear on record pages (companies, people, deals, etc.):

[**`record.actions: Array<App.Record.Action>`**](../extensions/record-action)

[**`record.bulkActions: Array<App.Record.BulkAction>`**](../extensions/bulk-record-action)

[**`record.widgets: Array<App.Record.Widget>`**](../extensions/record-widget)

### Call recording entry points

These appear in call recording contexts:

[**`callRecording.insight.textActions: Array<App.CallRecording.Insight.TextSelectionAction>`**](../extensions/call-recording-insight-text-action)

[**`callRecording.summary.textActions: Array<App.CallRecording.Summary.TextSelectionAction>`**](../extensions/call-recording-summary-text-action)

[**`callRecording.transcript.textActions: Array<App.CallRecording.Transcript.TextSelectionAction>`**](../extensions/call-recording-transcript-text-action)

## Best practices

### 1. Use descriptive names

Use clear, descriptive names for your entry points:

```typescript theme={"system"}
// Good: Clear and specific
import {sendInvoiceAction} from "./actions/send-invoice"
import {customerSummaryWidget} from "./widgets/customer-summary"

// Avoid: Generic names
import {recordAction} from "./actions/send-invoice"
import {recordWidget} from "./widgets/customer-summary"
```

### 2. Organize your file structure

Match your file structure to the `app` object organization:

```
src/
  app.ts
  record/
    actions/
      send-invoice.ts
      export-to-crm.ts
    widgets/
      customer-summary.ts
      arr-display.ts
    bulk-actions/
      bulk-export.ts
  callRecording/
    summary/
      capture-feedback.ts
    transcript/
      highlight-action.ts
```

### 3. Keep app.ts simple

The `app.ts` file should primarily contain imports and the configuration object. Keep business logic in the individual entry point files.

### 4. One entry point per file

Each entry point should be defined in its own file and exported. This makes them easier to test and maintain.